[mlir][linalg] Adapt the FillOp builder signature.

[gysit]

Summary

Change the build operand order from output, value to value, output. The patch makes the argument order consistent with the pretty printed order updated by https://reviews.llvm.org/D104356.

[nicolasvasilache]

With these uniformizations, do we need the custom printer and parser anymore (modulo some more minor spelling uniformizations re ins/outs) ?

[gysit]

In D104359#2829750, @nicolasvasilache wrote:

With these uniformizations, do we need the custom printer and parser anymore (modulo some more minor spelling uniformizations re ins/outs) ?

I would probably do that when switching to an OpDSL version?

[gysit]

Rebase.

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

def FillOp : LinalgStructured_Op<"fill", []> {
 
   let assemblyFormat = [{
     `(` $output `,` $value `)` attr-dict `:`
         type($output) `,` type($value) (`->` type($result)^)?
       custom<FillOpRegion>($region, ref(type($output)), ref($value))
   }];
 
   let builders = [
-    OpBuilder<(ins "Value":$output, "Value":$value)>
+    OpBuilder<(ins "Value":$value, "Value":$output)>
   ];
 
   let verifier = [{ return ::verify(*this); }];
 
   let hasFolder = 1;
 }
 
 /// A base class for pooling operation such as conv. The arguments must contain

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

static LogicalResult reduceMatchAndRewriteHelper(Operation *op, uint64_t axis,
 
   auto fillValueAttr = createInitialValueForReduceOp(op, elementTy, rewriter);
   if (!fillValueAttr)
     return rewriter.notifyMatchFailure(
         op, "No initial value found for reduction operation");
 
   auto fillValue = rewriter.create<ConstantOp>(loc, fillValueAttr);
   auto filledTensor =
-      rewriter.create<linalg::FillOp>(loc, initTensor, fillValue).result();
+      rewriter.create<linalg::FillOp>(loc, fillValue, initTensor).result();
 
   SmallVector<AffineExpr, 2> srcExprs;
   SmallVector<AffineExpr, 2> dstExprs;
   SmallVector<StringRef, 4> iteratorTypes;
   for (unsigned int i = 0, rank = inputTy.getRank(); i != rank; ++i) {
     srcExprs.push_back(mlir::getAffineDimExpr(i, rewriter.getContext()));
 
     iteratorTypes.push_back(axis == i ? getReductionIteratorTypeName()
matchAndRewrite(tosa::MatMulOp op, ArrayRef<Value> args,
 
     auto outputTy = op.getType().cast<ShapedType>();
     auto outputElementTy = outputTy.getElementType();
     auto zeroAttr = rewriter.getZeroAttr(outputElementTy);
     Value zero = rewriter.create<ConstantOp>(loc, zeroAttr);
     auto initTensor = rewriter.create<linalg::InitTensorOp>(
         loc, outputTy.getShape(), outputTy.getElementType());
     Value zeroTensor =
-        rewriter.create<linalg::FillOp>(loc, initTensor, zero).getResult(0);
+        rewriter.create<linalg::FillOp>(loc, zero, initTensor).getResult(0);
     rewriter.replaceOpWithNewOp<linalg::BatchMatmulOp>(
         op, TypeRange{op.getType()}, ValueRange{adaptor.a(), adaptor.b()},
         ValueRange{zeroTensor});
     return success();
   }
 };
 
 class FullyConnectedConverter
matchAndRewrite(tosa::FullyConnectedOp op, ArrayRef<Value> args,
 
     rewriter.replaceOpWithNewOp<linalg::MatmulOp>(
         op, TypeRange{op.getType()}, ValueRange{input, transposedWeight},
         linalgOp);
     return success();
   }
 };
 
-
 class ReshapeConverter : public OpConversionPattern<tosa::ReshapeOp> {
 public:
   using OpConversionPattern<tosa::ReshapeOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(tosa::ReshapeOp reshape, ArrayRef<Value> args,
                   ConversionPatternRewriter &rewriter) const final {
     typename tosa::ReshapeOp::Adaptor operands(args);
matchAndRewrite(tosa::ConcatOp op, ArrayRef<Value> args,
     sizes[axis] = resultDimSize;
 
     Value init = rewriter.create<linalg::InitTensorOp>(
         loc, resultType.getShape(), resultType.getElementType());
 
     Value zeroVal = rewriter.create<ConstantOp>(
         loc, rewriter.getZeroAttr(resultType.getElementType()));
     Value result =
-        rewriter.create<linalg::FillOp>(loc, init, zeroVal).getResult(0);
+        rewriter.create<linalg::FillOp>(loc, zeroVal, init).getResult(0);
 
     for (auto arg : args) {
       sizes[axis] = rewriter.create<memref::DimOp>(loc, arg, axisValue);
       result = rewriter.create<SubTensorInsertOp>(loc, arg, result, offsets,
                                                   sizes, strides);
       offsets[axis] = rewriter.create<AddIOp>(loc, offsets[axis], sizes[axis]);
     }
     rewriter.replaceOp(op, result);
LogicalResult matchAndRewrite(tosa::ArgMaxOp argmaxOp,
     auto initTensorIdx =
         rewriter
             .create<linalg::InitTensorOp>(loc, ArrayRef<Value>({}),
                                           resultTy.getShape(), outElementTy)
             .result();
     auto fillValueIdx = rewriter.create<ConstantOp>(
         loc, rewriter.getIntegerAttr(outElementTy, 0));
     auto filledTensorIdx =
-        rewriter.create<linalg::FillOp>(loc, initTensorIdx, fillValueIdx)
+        rewriter.create<linalg::FillOp>(loc, fillValueIdx, initTensorIdx)
             .result();
 
     // Second fill the output buffer for the running max.
     auto initTensorMax =
         rewriter
             .create<linalg::InitTensorOp>(loc, ArrayRef<Value>({}),
                                           resultTy.getShape(), inElementTy)
             .result();
     auto fillValueMaxAttr =
         createInitialValueForReduceOp(argmaxOp, inElementTy, rewriter);
 
     if (!fillValueMaxAttr)
       return rewriter.notifyMatchFailure(
           argmaxOp, "unsupported tosa.argmax element type");
 
     auto fillValueMax = rewriter.create<ConstantOp>(loc, fillValueMaxAttr);
     auto filledTensorMax =
-        rewriter.create<linalg::FillOp>(loc, initTensorMax, fillValueMax)
+        rewriter.create<linalg::FillOp>(loc, fillValueMax, initTensorMax)
             .result();
 
     // We need to reduce along the arg-max axis, with parallel operations along
     // the rest.
     SmallVector<StringRef, 4> iteratorTypes;
     iteratorTypes.resize(inputTy.getRank(), getParallelIteratorTypeName());
     iteratorTypes[axis] = getReductionIteratorTypeName();
 
LogicalResult matchAndRewrite(SrcOp op,
     Attribute strideAttr = rewriter.getI64VectorAttr(stride);
     Attribute dilationAttr = rewriter.getI64VectorAttr({1, 1});
 
     // Create the linalg op that performs pooling.
     Value initTensor = rewriter.create<linalg::InitTensorOp>(
         loc, resultTy.getShape(), resultTy.getElementType());
 
     Value filledInitTensor =
-        rewriter.create<linalg::FillOp>(loc, initTensor, initialValue).result();
+        rewriter.create<linalg::FillOp>(loc, initialValue, initTensor).result();
 
     Value fakeWindowDims =
         rewriter.create<linalg::InitTensorOp>(loc, kernel, outElementTy);
 
     auto createOp = [&](auto *typePtr) -> linalg::LinalgOp {
       return cast<linalg::LinalgOp>(
           rewriter
               .create<std::remove_pointer_t<decltype(typePtr)>>(

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 // FillOp
 //===----------------------------------------------------------------------===//
 void FillOp::regionBuilder(ImplicitLocOpBuilder &b, Block &block,
                            ValueRange captures) {
   assert(captures.size() == 1 && "FillOp regionBuilder expects 1 capture");
   b.create<linalg::YieldOp>(captures);
 }
 
-void FillOp::build(OpBuilder &builder, OperationState &result, Value output,
-                   Value value) {
+void FillOp::build(OpBuilder &builder, OperationState &result, Value value,
+                   Value output) {
   build(builder, result, output.getType().dyn_cast<RankedTensorType>(), output,
         value);
   fillStructuredOpRegion<FillOp>(builder, *result.regions.front(), TypeRange{},
                                  TypeRange{output.getType()}, value);
 }
 
 ParseResult parseFillOpRegion(OpAsmParser &parser, Region &r, Type outputType,
                               OpAsmParser::OperandType valueRef) {
LogicalResult matchAndRewrite(TensorReshapeOp reshapeOp,
     auto oldFill = reshapeOp.src().template getDefiningOp<FillOp>();
     if (!oldFill)
       return failure();
 
     Location loc = oldFill.getLoc();
     auto newInit = rewriter.create<TensorReshapeOp>(
         loc, reshapeOp.getResultType(), oldFill.output(),
         reshapeOp.reassociation());
-    rewriter.replaceOpWithNewOp<FillOp>(reshapeOp, newInit, oldFill.value());
+    rewriter.replaceOpWithNewOp<FillOp>(reshapeOp, oldFill.value(), newInit);
 
     return success();
   }
 };
 } // namespace
 
 void TensorExpandShapeOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {

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

public:
   LogicalResult
   matchAndRewrite(FillOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     linalg::FillOpAdaptor adaptor(operands, op->getAttrDictionary());
     if (!op.output().getType().isa<TensorType>())
       return rewriter.notifyMatchFailure(op,
                                          "operand must be of a tensor type");
 
-    rewriter.create<FillOp>(op.getLoc(), adaptor.output(), adaptor.value());
+    rewriter.create<FillOp>(op.getLoc(), adaptor.value(), adaptor.output());
     rewriter.replaceOp(op, adaptor.output());
 
     return success();
   }
 };
 
 /// Generic conversion pattern that matches any LinalgOp. This avoids template
 /// instantiating one pattern for each LinalgOp.

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

Value fillVal =
                 tmp = b.create<ConstantOp>(FloatAttr::get(et, 0.0));
               else if (auto et = t.getElementType().cast<IntegerType>())
                 tmp = b.create<ConstantOp>(IntegerAttr::get(et, 0));
               return b.create<complex::CreateOp>(t, tmp, tmp);
             })
             .Default([](auto) { return Value(); });
     if (!fillVal)
       return {};
-    b.create<linalg::FillOp>(promotionInfo->fullLocalView, fillVal);
+    b.create<linalg::FillOp>(fillVal, promotionInfo->fullLocalView);
   }
 
   // Copy data into the promoted buffers. Use callback if provided.
   for (auto v : options.subViews) {
     auto info = promotionInfoMap.find(v.first);
     if (info == promotionInfoMap.end())
       continue;
     if (failed(options.copyInFn(

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

LogicalResult PadTensorOpTransformationPattern::matchAndRewrite(
   Location loc = padOp.getLoc();
   SmallVector<Value> indices(resultShapedType.getRank(),
                              rewriter.create<ConstantIndexOp>(loc, 0));
   Value initTensor = rewriter.create<InitTensorOp>(
       loc, resultShapedType.getShape(), resultShapedType.getElementType());
 
   // Initialize tensor with the pad value
   Value tmpTensor =
-      rewriter.create<linalg::FillOp>(loc, initTensor, padValue).result();
+      rewriter.create<linalg::FillOp>(loc, padValue, initTensor).result();
 
   // Copy original contents into new tensor
   // Uses linalg.generic, but could be done with std.subtensor_insert
   SmallVector<AffineExpr, 4> outputExprs;
   for (unsigned i = 0; i < resultShapedType.getRank(); ++i) {
     outputExprs.push_back(getAffineDimExpr(i, rewriter.getContext()) +
                           padOp.static_low()[i].cast<IntegerAttr>().getInt());
   }

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

struct GenericPadTensorOpVectorizationPattern
   /// with a constant value. Otherwise, generate a tensor::GenerateOp.
   Value tryVectorizeFill(PatternRewriter &rewriter, PadTensorOp padOp,
                          Value dest, const SmallVector<Value> &dynSizes) const {
     // Fill can be vectorized if padValue is a constant. (If there is enough
     // static type information, the FillOp will be vectorized by another
     // pattern.)
     auto padValue = padOp.getConstantPaddingValue();
     if (padValue)
-      return rewriter.create<FillOp>(padOp.getLoc(), dest, padValue).result();
+      return rewriter.create<FillOp>(padOp.getLoc(), padValue, dest).result();
 
     // Fill could not be vectorized: Lower to tensor::GenerateOp with region.
     auto generateOp = rewriter.create<tensor::GenerateOp>(
         padOp.getLoc(), padOp.getResultType(), dynSizes);
     // Copy region to new op.
     BlockAndValueMapping bvm;
     padOp.region().cloneInto(&generateOp.getRegion(), bvm);
     // Rewrite linalg::YieldOp to tensor::YieldOp.

mlir/lib/Dialect/Vector/VectorTransforms.cpp

return b.create<scf::IfOp>(
         if (compatibleMemRefType != xferOp.getShapedType())
           res = b.create<memref::CastOp>(loc, memref, compatibleMemRefType);
         scf::ValueVector viewAndIndices{res};
         viewAndIndices.insert(viewAndIndices.end(), xferOp.indices().begin(),
                               xferOp.indices().end());
         b.create<scf::YieldOp>(loc, viewAndIndices);
       },
       [&](OpBuilder &b, Location loc) {
-        b.create<linalg::FillOp>(loc, alloc, xferOp.padding());
+        b.create<linalg::FillOp>(loc, xferOp.padding(), alloc);
         // Take partial subview of memref which guarantees no dimension
         // overflows.
         Value memRefSubView = createSubViewIntersection(
             b, cast<VectorTransferOpInterface>(xferOp.getOperation()), alloc);
         b.create<linalg::CopyOp>(loc, memRefSubView, alloc);
         Value casted =
             b.create<memref::CastOp>(loc, alloc, compatibleMemRefType);
         scf::ValueVector viewAndIndices{casted};

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

 }
 
 // Copy in call back
 static LogicalResult copyCallBackFn(OpBuilder &b, Value src, Value dst,
                                     bool isOutput) {
   auto floatType = src.getType().cast<MemRefType>().getElementType();
   if (!floatType.isa<FloatType>())
     return failure();
-  if (!isOutput)
-    b.create<FillOp>(
-        src.getLoc(), dst,
-        b.create<ConstantOp>(src.getLoc(), FloatAttr::get(floatType, 42.0)));
+  if (!isOutput) {
+    Value cst =
+        b.create<ConstantOp>(src.getLoc(), FloatAttr::get(floatType, 42.0));
+    b.create<FillOp>(src.getLoc(), cst, dst);
+  }
   b.create<CopyOp>(src.getLoc(), src, dst);
   return success();
 }
 
 static void fillPromotionCallBackPatterns(MLIRContext *ctx,
                                           RewritePatternSet &patterns) {
   patterns.add<LinalgTilingPattern<MatmulOp>>(
       ctx, LinalgTilingOptions().setTileSizes({16, 16, 16}),