[mlir] FuncInlinerInterface: Control whether a CallOp will be inlined

[rriddle]

The func dialect has no notion of a "noinline" attribute. Are you trying to propose such a thing here?

[mamrami]

I had a scenario where I wanted the callOp not to be inlined.
This is how I solved it, based on your change in Test dialect: https://reviews.llvm.org/D90359
Do you think I should implement it differently?

[jpienaar]

River's point is more that this attribute is not documented nor load bearing today, the legality depending on an attribute has not been specified and if you intend to propose this attribute as a load bearing concept for this op.

Now whether legal to inline may be getting should only be inlined in some case (there is an ongoing discussion on this on the forum).

[mamrami]

Do you suggest adding this attribute to the func dialect? Or do you suggest discussing the whole idea of not always returning true?

mlir/lib/Dialect/Func/IR/FuncOps.cpp

struct FuncInlinerInterface : public DialectInlinerInterface {
 
   //===--------------------------------------------------------------------===//
   // Analysis Hooks
   //===--------------------------------------------------------------------===//
 
   /// All call operations can be inlined.
   bool isLegalToInline(Operation *call, Operation *callable,
                        bool wouldBeCloned) const final {
-    return true;
+    return !call->hasAttr("noinline");
   }
 
   /// All operations can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 

mlir/test/Dialect/Func/inlining.mlir

+// RUN: mlir-opt -split-input-file -inline %s | FileCheck %s
+
+// CHECK-LABEL:   func.func @foo() -> memref<32x8xf32> {
+// CHECK:           %[[VAL_0:.*]] = call @bar() {noinline} : () -> memref<32x8xf32>
+// CHECK:           return %[[VAL_0]] : memref<32x8xf32>
+// CHECK:         }
+
+// CHECK-LABEL:   func.func private @bar() -> memref<32x8xf32> {
+// CHECK:           %[[VAL_0:.*]] = memref.alloc() : memref<32x8xf32>
+// CHECK:           return %[[VAL_0]] : memref<32x8xf32>
+// CHECK:         }
+
+module {
+  func.func @foo() -> memref<32x8xf32> {
+    %0 = call @bar() {noinline} : () -> memref<32x8xf32>
+    return %0 : memref<32x8xf32>
+  }
+  func.func private @bar() -> memref<32x8xf32> {
+    %0 = memref.alloc() : memref<32x8xf32>
+    return %0 : memref<32x8xf32>
+  }
+}
+
+// -----
+
+// CHECK-LABEL:     func.func @foo() -> memref<32x8xf32> {
+// CHECK:             %[[VAL_0:.*]] = memref.alloc() : memref<32x8xf32>
+// CHECK:             return %[[VAL_0]] : memref<32x8xf32>
+// CHECK:           }
+
+module {
+  func.func @foo() -> memref<32x8xf32> {
+    %0 = call @bar() : () -> memref<32x8xf32>
+    return %0 : memref<32x8xf32>
+  }
+  func.func private @bar() -> memref<32x8xf32> {
+    %0 = memref.alloc() : memref<32x8xf32>
+    return %0 : memref<32x8xf32>
+  }
+}