[mlir][NFC] Move the definition of AffineApplyOp to ODS

[rriddle]

Summary

This has been a long standing cleanup TODO.

Depends On D75968

[jpienaar]

Looks good, keeping it mostly mechanical is good :)

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

87

These could be derived attributes :-)

[bondhugula]

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

49

-> the affine mapping has to be one-dimensional, and so the affine.apply operation always returns one value.

?

67

? This doesn't appear clear to me.

mlir/lib/Dialect/AffineOps/AffineOps.cpp

247

AffineApplyOp::getOperationName() while at this.

[rriddle]

Resolve comments

mlir/include/mlir/Dialect/AffineOps/AffineOps.h

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Interfaces/SideEffects.h"
 #include "mlir/Transforms/LoopLikeInterface.h"
 
 namespace mlir {
+class AffineApplyOp;
 class AffineBound;
 class AffineDimExpr;
 class AffineValueMap;
 class AffineTerminatorOp;
 class FlatAffineConstraints;
 class OpBuilder;
 
 /// A utility function to check if a value is defined at the top level of a
 /// function. A value of index type defined at the top level is always a valid
 /// symbol.
 bool isTopLevelValue(Value value);
 
 class AffineOpsDialect : public Dialect {
 public:
   AffineOpsDialect(MLIRContext *context);
   static StringRef getDialectNamespace() { return "affine"; }
 
   /// Materialize a single constant operation from a given attribute value with
   /// the desired resultant type.
   Operation *materializeConstant(OpBuilder &builder, Attribute value, Type type,
                                  Location loc) override;
 };
 
-/// The "affine.apply" operation applies an affine map to a list of operands,
-/// yielding a single result. The operand list must be the same size as the
-/// number of arguments to the affine mapping.  All operands and the result are
-/// of type 'Index'. This operation requires a single affine map attribute named
-/// "map".  For example:
-///
-///   %y = "affine.apply" (%x) { map: (d0) -> (d0 + 1) } :
-///          (index) -> (index)
-///
-/// equivalently:
-///
-///   #map42 = (d0)->(d0+1)
-///   %y = affine.apply #map42(%x)
-///
-class AffineApplyOp : public Op<AffineApplyOp, OpTrait::VariadicOperands,
-                                OpTrait::OneResult, OpTrait::HasNoSideEffect> {
-public:
-  using Op::Op;
-
-  /// Builds an affine apply op with the specified map and operands.
-  static void build(Builder *builder, OperationState &result, AffineMap map,
-                    ValueRange operands);
-
-  /// Returns the affine map to be applied by this operation.
-  AffineMap getAffineMap() {
-    return getAttrOfType<AffineMapAttr>("map").getValue();
-  }
-
-  /// Returns the affine value map computed from this operation.
-  AffineValueMap getAffineValueMap();
-
-  /// Returns true if the result of this operation can be used as dimension id.
-  bool isValidDim();
-
-  /// Returns true if the result of this operation is a symbol.
-  bool isValidSymbol();
-
-  static StringRef getOperationName() { return "affine.apply"; }
-
-  operand_range getMapOperands() { return getOperands(); }
-
-  // Hooks to customize behavior of this op.
-  static ParseResult parse(OpAsmParser &parser, OperationState &result);
-  void print(OpAsmPrinter &p);
-  LogicalResult verify();
-  OpFoldResult fold(ArrayRef<Attribute> operands);
-
-  static void getCanonicalizationPatterns(OwningRewritePatternList &results,
-                                          MLIRContext *context);
-};
-
 /// AffineDmaStartOp starts a non-blocking DMA operation that transfers data
 /// from a source memref to a destination memref. The source and destination
 /// memref need not be of the same dimensionality, but need to have the same
 /// elemental type. The operands include the source and destination memref's
 /// each followed by its indices, size of the data transfer in terms of the
 /// number of elements (of the elemental type of the memref), a tag memref with
 /// its indices, and optionally at the end, a stride and a
 /// number_of_elements_per_stride arguments. The tag location is used by an

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

class Affine_Op<string mnemonic, list<OpTrait> traits = []> :
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 // Require regions to have affine terminator.
 def ImplicitAffineTerminator
     : SingleBlockImplicitTerminator<"AffineTerminatorOp">;
 
+def AffineApplyOp : Affine_Op<"apply", [NoSideEffect]> {
+  let summary = "affine apply operation";
+  let description = [{
+    The affine.apply operation applies an affine mapping to a list of SSA
+    values, yielding a single SSA value. The number of dimension and symbol
+    arguments to affine.apply must be equal to the respective number of
+    dimensional and symbolic inputs to the affine mapping; the affine mapping
+    has to be one-dimensional, and so the affine.apply operation always returns
+    one value. The input operands and result must all have ‘index’ type.
+
+    Example:
+
+    ```mlir
+      #map10 = affine_map<(d0, d1) -> (d0 floordiv 8 + d1 floordiv 128)>
+      ...
+      %1 = affine.apply #map10 (%s, %t)
+
+      // Inline example.
+      %2 = affine.apply affine_map<(i)[s0] -> (i+s0)> (%42)[%n]
+    ```
+  }];
+  let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$mapOperands);
+  let results = (outs Index);
+
+  // TODO: The auto-generated builders should check to see if the return type
+  // has a constant builder. That way we wouldn't need to explicitly specify the
+  // result types here.
+  let builders = [
+    OpBuilder<"Builder *builder, OperationState &result, "
+              "AffineMap map, ValueRange mapOperands", [{
+      build(builder, result, builder->getIndexType(), map, mapOperands);
+    }]>
+  ];
+
+  let extraClassDeclaration = [{
+    /// Returns the affine map to be applied by this operation.
+    AffineMap getAffineMap() { return map(); }
+
+    /// Returns the affine value map computed from this operation.
+    AffineValueMap getAffineValueMap();
+
+    /// Returns true if the result of this operation can be used as dimension id.
+    bool isValidDim();
+
+    /// Returns true if the result of this operation is a symbol.
+    bool isValidSymbol();
+
+    operand_range getMapOperands() { return getOperands(); }
+  }];
+
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
 def AffineForOp : Affine_Op<"for",
     [ImplicitAffineTerminator, RecursiveSideEffects,
      DeclareOpInterfaceMethods<LoopLikeOpInterface>]> {
   let summary = "for operation";
   let description = [{
     The "affine.for" operation represents an affine loop nest, defining an SSA
     value for its induction variable. It has one region capturing the loop body.
     The induction variable is represented as a argument of this region. This SSA

mlir/lib/Dialect/AffineOps/AffineOps.cpp

 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // AffineOpsDialect
 //===----------------------------------------------------------------------===//
 
 AffineOpsDialect::AffineOpsDialect(MLIRContext *context)
     : Dialect(getDialectNamespace(), context) {
-  addOperations<AffineApplyOp, AffineDmaStartOp, AffineDmaWaitOp, AffineLoadOp,
-                AffineStoreOp,
+  addOperations<AffineDmaStartOp, AffineDmaWaitOp, AffineLoadOp, AffineStoreOp,
 #define GET_OP_LIST
 #include "mlir/Dialect/AffineOps/AffineOps.cpp.inc"
                 >();
   addInterfaces<AffineInlinerInterface>();
 }
 
 /// Materialize a single constant operation from a given attribute value with
 /// the desired resultant type.
verifyDimAndSymbolIdentifiers(OpTy &op, Operation::operand_range operands,
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // AffineApplyOp
 //===----------------------------------------------------------------------===//
 
-void AffineApplyOp::build(Builder *builder, OperationState &result,
-                          AffineMap map, ValueRange operands) {
-  result.addOperands(operands);
-  result.types.append(map.getNumResults(), builder->getIndexType());
-  result.addAttribute("map", AffineMapAttr::get(map));
-}
-
 AffineValueMap AffineApplyOp::getAffineValueMap() {
   return AffineValueMap(getAffineMap(), getOperands(), getResult());
 }
 
-ParseResult AffineApplyOp::parse(OpAsmParser &parser, OperationState &result) {
+static ParseResult parseAffineApplyOp(OpAsmParser &parser,
+                                      OperationState &result) {
   auto &builder = parser.getBuilder();
   auto indexTy = builder.getIndexType();
 
   AffineMapAttr mapAttr;
   unsigned numDims;
   if (parser.parseAttribute(mapAttr, "map", result.attributes) ||
       parseDimAndSymbolList(parser, result.operands, numDims) ||
       parser.parseOptionalAttrDict(result.attributes))
     return failure();
   auto map = mapAttr.getValue();
 
   if (map.getNumDims() != numDims ||
       numDims + map.getNumSymbols() != result.operands.size()) {
     return parser.emitError(parser.getNameLoc(),
                             "dimension or symbol index mismatch");
   }
 
   result.types.append(map.getNumResults(), indexTy);
   return success();
 }
 
-void AffineApplyOp::print(OpAsmPrinter &p) {
-  p << "affine.apply " << getAttr("map");
-  printDimAndSymbolList(operand_begin(), operand_end(),
-                        getAffineMap().getNumDims(), p);
-  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"map"});
+static void print(OpAsmPrinter &p, AffineApplyOp op) {
+  p << AffineApplyOp::getOperationName() << " " << op.mapAttr();
+  printDimAndSymbolList(op.operand_begin(), op.operand_end(),
+                        op.getAffineMap().getNumDims(), p);
+  p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"map"});
 }
 
-LogicalResult AffineApplyOp::verify() {
-  // Check that affine map attribute was specified.
-  auto affineMapAttr = getAttrOfType<AffineMapAttr>("map");
-  if (!affineMapAttr)
-    return emitOpError("requires an affine map");
-
+static LogicalResult verify(AffineApplyOp op) {
   // Check input and output dimensions match.
-  auto map = affineMapAttr.getValue();
+  auto map = op.map();
 
   // Verify that operand count matches affine map dimension and symbol count.
-  if (getNumOperands() != map.getNumDims() + map.getNumSymbols())
-    return emitOpError(
+  if (op.getNumOperands() != map.getNumDims() + map.getNumSymbols())
+    return op.emitOpError(
         "operand count and affine map dimension and symbol count must match");
 
-  // Verify that all operands are of `index` type.
-  for (Type t : getOperandTypes()) {
-    if (!t.isIndex())
-      return emitOpError("operands must be of type 'index'");
-  }
-
-  if (!getResult().getType().isIndex())
-    return emitOpError("result must be of type 'index'");
-
   // Verify that the map only produces one result.
   if (map.getNumResults() != 1)
-    return emitOpError("mapping must produce one value");
+    return op.emitOpError("mapping must produce one value");
 
   return success();
 }
 
 // The result of the affine apply operation can be used as a dimension id if all
 // its operands are valid dimension ids.
 bool AffineApplyOp::isValidDim() {
   return llvm::all_of(getOperands(),

mlir/test/Dialect/AffineOps/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 
 func @affine_apply_operand_non_index(%arg0 : i32) {
   // Custom parser automatically assigns all arguments the `index` so we must
   // use the generic syntax here to exercise the verifier.
-  // expected-error@+1 {{operands must be of type 'index'}}
+  // expected-error@+1 {{op operand #0 must be index, but got 'i32'}}
   %0 = "affine.apply"(%arg0) {map = affine_map<(d0) -> (d0)>} : (i32) -> (index)
   return
 }
 
 // -----
 
 func @affine_apply_resul_non_index(%arg0 : index) {
   // Custom parser automatically assigns `index` as the result type so we must
   // use the generic syntax here to exercise the verifier.
-  // expected-error@+1 {{result must be of type 'index'}}
+  // expected-error@+1 {{op result #0 must be index, but got 'i32'}}
   %0 = "affine.apply"(%arg0) {map = affine_map<(d0) -> (d0)>} : (index) -> (i32)
   return
 }
 
 // -----
 
 #map = affine_map<(d0)[s0] -> (d0 + s0)>
 

mlir/test/IR/invalid-ops.mlir

^bb:
   %x = "std.constant"(){value = 10.} : () -> f32 // expected-error {{requires attribute's type ('f64') to match op's return type ('f32')}}
   return
 }
 
 // -----
 func @affine_apply_no_map() {
 ^bb0:
   %i = constant 0 : index
-  %x = "affine.apply" (%i) { } : (index) -> (index) //  expected-error {{'affine.apply' op requires an affine map}}
+  %x = "affine.apply" (%i) { } : (index) -> (index) //  expected-error {{'affine.apply' op requires attribute 'map'}}
   return
 }
 
 // -----
 
 func @affine_apply_wrong_operand_count() {
 ^bb0:
   %i = constant 0 : index