Merge branch 'mlir-call-attrs-iface' into mlir-call-attrs-llvm

Author: jeanPerier

mlir/include/mlir/Interfaces/CallImplementation.h

@@ -20,8 +20,6 @@
 
 namespace mlir {
 
-class OpWithArgumentAttributesInterface;
-
 namespace call_interface_impl {
 
 /// Parse a function or call result list.
@@ -65,8 +63,7 @@ ParseResult parseFunctionSignature(OpAsmParser &parser,
 ///                            -> function-result-list
 ///   ssa-function-arg-list  ::= ssa-function-arg (`,` ssa-function-arg)*
 ///   ssa-function-arg       ::= `%`name `:` type attribute-dict?
-void printFunctionSignature(OpAsmPrinter &p,
-                            OpWithArgumentAttributesInterface op,
+void printFunctionSignature(OpAsmPrinter &p, ArgumentAttributesOpInterface op,
                             TypeRange argTypes, bool isVariadic,
                             TypeRange resultTypes, Region *body = nullptr,
                             bool printEmptyResult = true);

mlir/include/mlir/Interfaces/CallInterfaces.td

@@ -20,9 +20,10 @@ include "mlir/IR/OpBase.td"
 
 /// Interface for operations with arguments attributes (both call-like
 /// and callable operations).
-def OpWithArgumentAttributesInterface : OpInterface<"OpWithArgumentAttributesInterface"> {
+def ArgumentAttributesOpInterface : OpInterface<"ArgumentAttributesOpInterface"> {
   let description = [{
-    A call-like or callable operation that may define attributes for its arguments. 
+    A call-like or callable operation that can hold attributes for its arguments
+    and results.
   }];
   let cppNamespace = "::mlir";
   let methods = [
@@ -32,40 +33,34 @@ def OpWithArgumentAttributesInterface : OpInterface<"OpWithArgumentAttributesInt
         number to the number of arguments. Alternatively, the method can
         return null to indicate that the region has no argument attributes.
       }],
-      "::mlir::ArrayAttr", "getArgAttrsAttr", (ins),
-      /*methodBody=*/[{}], /*defaultImplementation=*/[{ return nullptr; }]>,
+      "::mlir::ArrayAttr", "getArgAttrsAttr">,
     InterfaceMethod<[{
         Get the array of result attribute dictionaries. The method should return
         an array attribute containing only dictionary attributes equal in number
         to the number of results. Alternatively, the method can return
         null to indicate that the region has no result attributes.
       }],
-      "::mlir::ArrayAttr", "getResAttrsAttr", (ins),
-      /*methodBody=*/[{}], /*defaultImplementation=*/[{ return nullptr; }]>,
+      "::mlir::ArrayAttr", "getResAttrsAttr">,
     InterfaceMethod<[{
       Set the array of argument attribute dictionaries.
     }],
-    "void", "setArgAttrsAttr", (ins "::mlir::ArrayAttr":$attrs),
-      /*methodBody=*/[{}], /*defaultImplementation=*/[{ return; }]>,
+    "void", "setArgAttrsAttr", (ins "::mlir::ArrayAttr":$attrs)>,
     InterfaceMethod<[{
       Set the array of result attribute dictionaries.
     }],
-    "void", "setResAttrsAttr", (ins "::mlir::ArrayAttr":$attrs),
-      /*methodBody=*/[{}], /*defaultImplementation=*/[{ return; }]>,
+    "void", "setResAttrsAttr", (ins "::mlir::ArrayAttr":$attrs)>,
     InterfaceMethod<[{
       Remove the array of argument attribute dictionaries. This is the same as
       setting all argument attributes to an empty dictionary. The method should
       return the removed attribute.
     }],
-    "::mlir::Attribute", "removeArgAttrsAttr", (ins),
-      /*methodBody=*/[{}], /*defaultImplementation=*/[{ return nullptr; }]>,
+    "::mlir::Attribute", "removeArgAttrsAttr">,
     InterfaceMethod<[{
       Remove the array of result attribute dictionaries. This is the same as
       setting all result attributes to an empty dictionary. The method should
       return the removed attribute.
     }],
-    "::mlir::Attribute", "removeResAttrsAttr", (ins),
-      /*methodBody=*/[{}], /*defaultImplementation=*/[{ return nullptr; }]>,
+    "::mlir::Attribute", "removeResAttrsAttr">
   ];
 }
 
@@ -74,8 +69,7 @@ def OpWithArgumentAttributesInterface : OpInterface<"OpWithArgumentAttributesInt
 // a call-like operation. This represents the destination of the call.
 
 /// Interface for call-like operations.
-def CallOpInterface : OpInterface<"CallOpInterface",
-    [OpWithArgumentAttributesInterface]> {
+def CallOpInterface : OpInterface<"CallOpInterface"> {
   let description = [{
     A call-like operation is one that transfers control from one sub-routine to
     another. These operations may be traditional direct calls `call @foo`, or
@@ -138,8 +132,7 @@ def CallOpInterface : OpInterface<"CallOpInterface",
 }
 
 /// Interface for callable operations.
-def CallableOpInterface : OpInterface<"CallableOpInterface",
-    [OpWithArgumentAttributesInterface]> {
+def CallableOpInterface : OpInterface<"CallableOpInterface"> {
   let description = [{
     A callable operation is one who represents a potential sub-routine, and may
     be a target for a call-like operation (those providing the CallOpInterface

mlir/include/mlir/Interfaces/FunctionInterfaces.td

@@ -22,7 +22,7 @@ include "mlir/Interfaces/CallInterfaces.td"
 //===----------------------------------------------------------------------===//
 
 def FunctionOpInterface : OpInterface<"FunctionOpInterface", [
-    Symbol, CallableOpInterface
+    Symbol, CallableOpInterface, ArgumentAttributesOpInterface
   ]> {
   let cppNamespace = "::mlir";
   let description = [{

mlir/lib/Interfaces/CallImplementation.cpp

@@ -95,7 +95,7 @@ static void printFunctionResultList(OpAsmPrinter &p, TypeRange types,
 }
 
 void call_interface_impl::printFunctionSignature(
-    OpAsmPrinter &p, OpWithArgumentAttributesInterface op, TypeRange argTypes,
+    OpAsmPrinter &p, ArgumentAttributesOpInterface op, TypeRange argTypes,
     bool isVariadic, TypeRange resultTypes, Region *body,
     bool printEmptyResult) {
   bool isExternal = !body || body->empty();

mlir/lib/Transforms/Utils/InliningUtils.cpp

@@ -193,11 +193,13 @@ static void handleArgumentImpl(InlinerInterface &interface, OpBuilder &builder,
   SmallVector<DictionaryAttr> argAttrs(
       callable.getCallableRegion()->getNumArguments(),
       builder.getDictionaryAttr({}));
-  if (ArrayAttr arrayAttr = callable.getArgAttrsAttr()) {
-    assert(arrayAttr.size() == argAttrs.size());
-    for (auto [idx, attr] : llvm::enumerate(arrayAttr))
-      argAttrs[idx] = cast<DictionaryAttr>(attr);
-  }
+  if (auto argAttrsOpInterface =
+          dyn_cast<ArgumentAttributesOpInterface>(callable.getOperation()))
+    if (ArrayAttr arrayAttr = argAttrsOpInterface.getArgAttrsAttr()) {
+      assert(arrayAttr.size() == argAttrs.size());
+      for (auto [idx, attr] : llvm::enumerate(arrayAttr))
+        argAttrs[idx] = cast<DictionaryAttr>(attr);
+    }
 
   // Run the argument attribute handler for the given argument and attribute.
   for (auto [blockArg, argAttr] :
@@ -218,11 +220,13 @@ static void handleResultImpl(InlinerInterface &interface, OpBuilder &builder,
   // Unpack the result attributes if there are any.
   SmallVector<DictionaryAttr> resAttrs(results.size(),
                                        builder.getDictionaryAttr({}));
-  if (ArrayAttr arrayAttr = callable.getResAttrsAttr()) {
-    assert(arrayAttr.size() == resAttrs.size());
-    for (auto [idx, attr] : llvm::enumerate(arrayAttr))
-      resAttrs[idx] = cast<DictionaryAttr>(attr);
-  }
+  if (auto argAttrsOpInterface =
+          dyn_cast<ArgumentAttributesOpInterface>(callable.getOperation()))
+    if (ArrayAttr arrayAttr = argAttrsOpInterface.getResAttrsAttr()) {
+      assert(arrayAttr.size() == resAttrs.size());
+      for (auto [idx, attr] : llvm::enumerate(arrayAttr))
+        resAttrs[idx] = cast<DictionaryAttr>(attr);
+    }
 
   // Run the result attribute handler for the given result and attribute.
   SmallVector<DictionaryAttr> resultAttributes;