[mlir][Linalg] Remove initial value for conditions.

[hanchung]

Summary

Although bool and int1 are the same sometimes, using bool constant matches the
semantic better. In any cases, we don't have to care the type of conditions if
we remove the intial value. The type is determined automatically by the returned
type of logical operations.

[mravishankar]

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

190

Maybe avoid having a "initial value" altogether? Just check if conds.size() == 0 to check if a condition already exists in the stack.

[nicolasvasilache]

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

190

+1, then the idiomatic MLIR way is to use conds.empty()

[hanchung]

Address comment and update commit message.

[hanchung]

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

190

Good point, and we can just rely on the return type of logical operations.

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

public:
   /// Returns the input value of convOp. If the indices in `imIdx` is out of
   /// boundrary, returns 0 instead.
   static ValueHandle getConvOpInput(ConvOp convOp, IndexedValueType im,
                                     ArrayRef<ValueHandle> imIdx) {
     // TODO(ntv): add a level of indirection to linalg.generic.
     if (!convOp.padding())
       return im(imIdx);
 
+    auto *context = ScopedContext::getContext();
     ValueHandle zeroIndex = std_constant_index(0);
-    SmallVector<ValueHandle, 8> conds = {
-        std_constant_int(/*value=*/1, /*width=*/1)};
+    SmallVector<ValueHandle, 8> conds;
     SmallVector<ValueHandle, 8> clampedImIdx;
     for (auto iter : llvm::enumerate(imIdx)) {
       int idx = iter.index();
       auto dim = iter.value();
       // Only need to iterate over the window dimensions.
       if (idx == 0 || idx == static_cast<int>(imIdx.size()) - 1) {
         clampedImIdx.push_back(dim);
         continue;
       }
 
       using edsc::op::operator<;
       using edsc::op::operator>=;
       using edsc::op::operator||;
-      conds.push_back(conds.back() || (dim < zeroIndex));
-      ValueHandle bound = std_dim(convOp.input(), idx);
-      conds.push_back(conds.back() || (dim >= bound));
+      ValueHandle leftOutOfBound = dim < zeroIndex;
+      if (conds.empty())
+        conds.push_back(leftOutOfBound);
+      else
+        conds.push_back(conds.back() || leftOutOfBound);
+      ValueHandle rightBound = std_dim(convOp.input(), idx);
+      conds.push_back(conds.back() || (dim >= rightBound));
 
       // When padding is involed, the indices will only be shifted to negative,
       // so having a max op is enough.
-      auto *context = ScopedContext::getContext();
       auto maxMap = AffineMap::get(/*dimCount=*/1, 0,
                                    {getAffineDimExpr(/*position=*/0, context),
                                     getAffineConstantExpr(0, context)});
       clampedImIdx.push_back(
           affine_max(dim.getType(), maxMap, ValueRange{dim}));
     }
 
     auto b = ScopedContext::getBuilder();
     Type type = convOp.input().getType().cast<MemRefType>().getElementType();
     ValueHandle zero = std_constant(type, b.getZeroAttr(type));
     ValueHandle readInput = im(clampedImIdx);
-    return std_select(conds.back(), zero, readInput);
+    return conds.empty() ? readInput
+                         : std_select(conds.back(), zero, readInput);
   }
 
   static void emitScalarImplementation(ArrayRef<Value> allIvs, ConvOp convOp) {
     assert(convOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     auto b = ScopedContext::getBuilder();
     auto loc = ScopedContext::getLocation();
     auto mapsRange = convOp.indexing_maps().getAsRange<AffineMapAttr>();