[MLIR] feat(mlir-tblgen): Add support for dialect interfaces

mlir/include/mlir/IR/Interfaces.td

@@ -147,6 +147,11 @@ class TypeInterface<string name, list<Interface> baseInterfaces = []>
 			!if(!empty(cppNamespace),"", cppNamespace # "::") # name
     >;
 
+// DialectInterface represents a Dialect Interface.
+class DialectInterface<string name, list<Interface> baseInterfaces = []>
+  : Interface<name, baseInterfaces>, OpInterfaceTrait<name>;
+
+
 // Whether to declare the interface methods in the user entity's header. This
 // class simply wraps an Interface but is used to indicate that the method
 // declarations should be generated. This class takes an optional set of methods

mlir/include/mlir/TableGen/Interfaces.h

@@ -157,6 +157,13 @@ struct TypeInterface : public Interface {
 
   static bool classof(const Interface *interface);
 };
+// An interface that is registered to a Dialect.
+struct DialectInterface : public Interface {
+  using Interface::Interface;
+
+  static bool classof(const Interface *interface);
+};
+
 } // namespace tblgen
 } // namespace mlir
 

mlir/include/mlir/Transforms/CMakeLists.txt

@@ -5,4 +5,8 @@ mlir_tablegen(Transforms.capi.h.inc -gen-pass-capi-header --prefix Transforms)
 mlir_tablegen(Transforms.capi.cpp.inc -gen-pass-capi-impl --prefix Transforms)
 add_mlir_dialect_tablegen_target(MLIRTransformsPassIncGen)
 
+set(LLVM_TARGET_DEFINITIONS DialectInlinerInterface.td)
+mlir_tablegen(DialectInlinerInterface.h.inc -gen-dialect-interface-decls)
+add_mlir_dialect_tablegen_target(MLIRTransformsDialectInterfaceIncGen)
+
 add_mlir_doc(Passes GeneralPasses ./ -gen-pass-doc)

mlir/include/mlir/Transforms/DialectInlinerInterface.td

@@ -0,0 +1,217 @@
+#ifndef DIALECTINLINERINTERFACE
+#define DIALECTINLINERINTERFACE
+
+include "mlir/IR/Interfaces.td"
+
+def DialectInlinerInterface : DialectInterface<"DialectInlinerInterface"> {
+  let description = [{
+    This is the interface that must be implemented by the dialects of operations
+    to be inlined. This interface should only handle the operations of the
+    given dialect.
+    }];
+
+
+  let cppNamespace = "::mlir";
+
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/        [{
+        Returns true if the given operation 'callable', that implements the
+        'CallableOpInterface', can be inlined into the position given call
+        operation 'call', that is registered to the current dialect and implements
+        the `CallOpInterface`. 'wouldBeCloned' is set to true if the region of the
+        given 'callable' is set to be cloned during the inlining process, or false
+        if the region is set to be moved in-place(i.e. no duplicates would be
+        created).
+      }],
+      /*returnType=*/  "bool",
+      /*methodName=*/  "isLegalToInline",
+      /*args=*/        (ins "::mlir::Operation *":$call, "::mlir::Operation *":$callable, "bool":$wouldBeCloned),
+      /*methodBody=*/  [{
+        return false;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Returns true if the given region 'src' can be inlined into the region
+        'dest' that is attached to an operation registered to the current dialect.
+        'wouldBeCloned' is set to true if the given 'src' region is set to be
+        cloned during the inlining process, or false if the region is set to be
+        moved in-place(i.e. no duplicates would be created). 'valueMapping'
+        contains any remapped values from within the 'src' region. This can be
+        used to examine what values will replace entry arguments into the 'src'
+        region for example.
+      }],
+      /*returnType=*/  "bool",
+      /*methodName=*/  "isLegalToInline",
+      /*args=*/        (ins "::mlir::Region *":$dest, "::mlir::Region *":$src, "bool":$wouldBeCloned,
+                        "::mlir::IRMapping &":$valueMapping),
+      /*methodBody=*/  [{
+        return false;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Returns true if the given region 'src' can be inlined into the region
+        'dest' that is attached to an operation registered to the current dialect.
+        'wouldBeCloned' is set to true if the given 'src' region is set to be
+        cloned during the inlining process, or false if the region is set to be
+        moved in-place(i.e. no duplicates would be created). 'valueMapping'
+        contains any remapped values from within the 'src' region. This can be
+        used to examine what values will replace entry arguments into the 'src'
+        region for example.
+      }],
+      /*returnType=*/  "bool",
+      /*methodName=*/  "isLegalToInline",
+      /*args=*/        (ins "::mlir::Operation *":$op, "::mlir::Region *":$dest, "bool":$wouldBeCloned,
+                        "::mlir::IRMapping &":$valueMapping),
+      /*methodBody=*/  [{
+        return false;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        This hook is invoked on an operation that contains regions. It should
+        return true if the analyzer should recurse within the regions of this
+        operation when computing legality and cost, false otherwise. The default
+        implementation returns true.
+      }],
+      /*returnType=*/  "bool",
+      /*methodName=*/  "shouldAnalyzeRecursively",
+      /*args=*/        (ins "::mlir::Operation *":$op),
+      /*methodBody=*/  [{
+        return true;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Handle the given inlined terminator by replacing it with a new operation
+        as necessary. This overload is called when the inlined region has more
+        than one block. The 'newDest' block represents the new final branching
+        destination of blocks within this region, i.e. operations that release
+        control to the parent operation will likely now branch to this block.
+        Its block arguments correspond to any values that need to be replaced by
+        terminators within the inlined region.
+      }],
+      /*returnType=*/  "void",
+      /*methodName=*/  "handleTerminator",
+  /*args=*/        (ins "::mlir::Operation *":$op, "::mlir::Block *":$newDest),
+      /*methodBody=*/  [{
+        llvm_unreachable("must implement handleTerminator in the case of multiple "
+                         "inlined blocks");
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Handle the given inlined terminator by replacing it with a new operation
+        as necessary. This overload is called when the inlined region only
+        contains one block. 'valuesToReplace' contains the previously returned
+        values of the call site before inlining. These values must be replaced by
+        this callback if they had any users (for example for traditional function
+        calls, these are directly replaced with the operands of the `return`
+        operation). The given 'op' will be removed by the caller, after this
+        function has been called.
+      }],
+      /*returnType=*/  "void",
+      /*methodName=*/  "handleTerminator",
+      /*args=*/        (ins "::mlir::Operation *":$op, "::mlir::ValueRange":$valuesToReplace),
+      /*methodBody=*/  [{
+        llvm_unreachable(
+            "must implement handleTerminator in the case of one inlined block");
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Attempt to materialize a conversion for a type mismatch between a call
+        from this dialect, and a callable region. This method should generate an
+        operation that takes 'input' as the only operand, and produces a single
+        result of 'resultType'. If a conversion can not be generated, nullptr
+        should be returned. For example, this hook may be invoked in the following
+        scenarios:
+          func @foo(i32) -> i32 { ... }
+
+          // Mismatched input operand
+          ... = foo.call @foo(%input : i16) -> i32
+
+          // Mismatched result type.
+          ... = foo.call @foo(%input : i32) -> i16
+
+        NOTE: This hook may be invoked before the 'isLegal' checks above.
+      }],
+      /*returnType=*/  "::mlir::Operation *",
+      /*methodName=*/  "materializeCallConversion",
+      /*args=*/        (ins "::mlir::OpBuilder &":$builder, "::mlir::Value":$input, 
+                        "::mlir::Type":$resultType, "::mlir::Location":$conversionLoc),
+      /*methodBody=*/  [{
+        return nullptr;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Hook to transform the call arguments before using them to replace the
+        callee arguments. Returns a value of the same type or the `argument`
+        itself if nothing changed. The `argumentAttrs` dictionary is non-null even
+        if no attribute is present. The hook is called after converting the
+        callsite argument types using the materializeCallConversion callback, and
+        right before inlining the callee region. Any operations created using the
+        provided `builder` are inserted right before the inlined callee region. An
+        example use case is the insertion of copies for by value arguments.
+      }],
+      /*returnType=*/  "::mlir::Value",
+      /*methodName=*/  "handleArgument",
+      /*args=*/        (ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call, 
+                        "::mlir::Operation *":$callable, "::mlir::Value":$argument,
+                        "::mlir::DictionaryAttr":$argumentAttrs),
+      /*methodBody=*/  [{
+        return argument;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Hook to transform the callee results before using them to replace the call
+        results. Returns a value of the same type or the `result` itself if
+        nothing changed. The `resultAttrs` dictionary is non-null even if no
+        attribute is present. The hook is called right before handling
+        terminators, and obtains the callee result before converting its type
+        using the `materializeCallConversion` callback. Any operations created
+        using the provided `builder` are inserted right after the inlined callee
+        region. An example use case is the insertion of copies for by value
+        results. NOTE: This hook is invoked after inlining the `callable` region.
+      }],
+      /*returnType=*/  "::mlir::Value",
+      /*methodName=*/  "handleResult",
+      /*args=*/        (ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call, 
+                        "::mlir::Operation *":$callable, "::mlir::Value":$result,
+                        "::mlir::DictionaryAttr":$resultAttrs),
+      /*methodBody=*/  [{
+        return result;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Process a set of blocks that have been inlined for a call. This callback
+        is invoked before inlined terminator operations have been processed.
+      }],
+      /*returnType=*/  "void",
+      /*methodName=*/  "processInlinedCallBlocks",
+      /*args=*/        (ins "::mlir::Operation *":$call, 
+                        "::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks),
+      /*methodBody=*/  [{}]
+    >,
+    InterfaceMethod<
+      /*desc=*/        [{
+        Returns true if the inliner can assume a fast path of not creating a new
+        block, if there is only one block.
+      }],
+      /*returnType=*/  "bool",
+      /*methodName=*/  "allowSingleBlockOptimization",
+      /*args=*/        (ins "::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks),
+      /*methodBody=*/  [{
+        return true;
+      }]
+    >
+  ];
+}
+
+
+#endif