[mlir][Tensor] Add a helper build method for pad operations with constant padding.

[hanchung]

I think we already have a similar method in tensor/Utils.h. Does it fit your needs?

// Return a PadOp that pads `source to `type` size with `pad` value.
// I.e., a block will be created and the `pad` value will be yielded
// directly. If the type passed is nullptr, it is inferred.
PadOp createPadScalarOp(Type type, Value source, Value pad,
                        ArrayRef<OpFoldResult> low, ArrayRef<OpFoldResult> high,
                        bool nofold, Location loc, OpBuilder &builder);

[mravishankar]

In D136493#3875849, @hanchung wrote:

I think we already have a similar method in tensor/Utils.h. Does it fit your needs?

// Return a PadOp that pads `source to `type` size with `pad` value.
// I.e., a block will be created and the `pad` value will be yielded
// directly. If the type passed is nullptr, it is inferred.
PadOp createPadScalarOp(Type type, Value source, Value pad,
                        ArrayRef<OpFoldResult> low, ArrayRef<OpFoldResult> high,
                        bool nofold, Location loc, OpBuilder &builder);

Maybe we should just drop that method....

[mravishankar]

Drop duplicate method in Tensor/Utils.h.

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

OpBuilder<(ins "Value":$source, "ValueRange":$low, "ValueRange":$high,
       CArg<"bool", "false">:$nofold,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a PadOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Type":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
       CArg<"bool", "false">:$nofold,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    // Build a PadOp with constant padding,  mixed static and dynamic entries
+    // and custom result type. If the type passed is nullptr, it is inferred.
+    OpBuilder<(ins "Type":$resultType, "Value":$source,
+      "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
+      "Value":$constantPadValue, CArg<"bool", "false">:$nofold,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
   let hasRegionVerifier = 1;
 }
 

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

void PadOp::build(OpBuilder &b, OperationState &result, Value source,
   build(b, result, source, staticVector, staticVector, low, high, nofold,
         attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ArrayRef<OpFoldResult> low,
                   ArrayRef<OpFoldResult> high, bool nofold,
                   ArrayRef<NamedAttribute> attrs) {
-  assert(resultType.isa<RankedTensorType>());
   auto sourceType = source.getType().cast<RankedTensorType>();
   SmallVector<Value, 4> dynamicLow, dynamicHigh;
   SmallVector<int64_t, 4> staticLow, staticHigh;
   // staticLow and staticHigh have full information of the padding config.
   // This will grow staticLow and staticHigh with 1 value. If the config is
   // dynamic (ie not a constant), dynamicLow and dynamicHigh will grow with 1
   // value as well.
   dispatchIndexOpFoldResults(low, dynamicLow, staticLow,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(high, dynamicHigh, staticHigh,
                              ShapedType::kDynamicSize);
   if (!resultType) {
     resultType = PadOp::inferResultType(sourceType, staticLow, staticHigh);
   }
+  assert(resultType.isa<RankedTensorType>());
   build(b, result, resultType, source, dynamicLow, dynamicHigh,
         b.getI64ArrayAttr(staticLow), b.getI64ArrayAttr(staticHigh),
         nofold ? b.getUnitAttr() : UnitAttr());
   result.addAttributes(attrs);
 }
 
+void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
+                  Value source, ArrayRef<OpFoldResult> low,
+                  ArrayRef<OpFoldResult> high, Value constantPadValue,
+                  bool nofold, ArrayRef<NamedAttribute> attrs) {
+  build(b, result, resultType, source, low, high, nofold, attrs);
+
+  // Add a region and a block to yield the pad value.
+  Region *region = result.regions[0].get();
+  region->push_back(new Block);
+  Block &body = region->front();
+  for (auto dim : llvm::seq<unsigned>(
+           0, source.getType().cast<RankedTensorType>().getRank())) {
+    body.addArgument(b.getIndexType(), result.location);
+  }
+  OpBuilder::InsertionGuard guard(b);
+  b.setInsertionPointToStart(&body);
+  b.create<tensor::YieldOp>(result.location, constantPadValue);
+}
+
 llvm::SmallBitVector PadOp::getPaddedDims() {
   llvm::SmallBitVector paddedDims(getSourceType().getRank());
   auto extractPaddedDims = [&](ArrayRef<OpFoldResult> paddingWidths) {
     for (const auto &en : enumerate(paddingWidths))
       if (getConstantIntValue(en.value()) != static_cast<int64_t>(0))
         paddedDims.set(en.index());
   };
   extractPaddedDims(getMixedLowPad());