[mlir][LLVM] Finer-grained control for C interface emission

[nicolasvasilache]

Summary

C interface emission is controlled by a flag and has coarse granularity.
With this coarse control, interfaces are emitted for all external functions.
This makes is easy to get undefined symbols.

This revision adds support for controlling per-function emission with an "emit_c_interface" attribute.

[ftynse]

mlir/include/mlir/IR/Function.h

96

I would not leak implementation details of std->llvm lowering into core IR. We can have a dialect attribute llvm.emit_c_interface attached to a FuncOp without having FuncOp know about it. Then the lowering can check for it.

[mehdi_amini]

mlir/include/mlir/IR/Function.h

96

+1: seems like a layering violation right now.

[nicolasvasilache]

Avoid leaking into FuncOp.

[ftynse]

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

1134

Spurious reformatting.

[ftynse]

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

1134

Note that I removed this code altogether, make sure not to re-add this during rebase, thanks!

[nicolasvasilache]

Drop spurious formatting.

[nicolasvasilache]

Rebase.

[rriddle]

It would be nice to keep track of all of the different ways that the ABI is being expressed.

[nicolasvasilache]

This landed as: add9f1a5dc1963149dac4cb8b25bf2cb825a02c2

mlir/docs/ConversionToLLVMDialect.md

 }
 ```
 
 *This convention may or may not apply if the conversion of MemRef types is
 overridden by the user.*
 
 ### C-compatible wrapper emission
 
-In practical cases, it may be desirable to have externally-facing functions
-with a single attribute corresponding to a MemRef argument. When interfacing
-with LLVM IR produced from C, the code needs to respect the corresponding
-calling convention. The conversion to the LLVM dialect provides an option to
-generate wrapper functions that take memref descriptors as pointers-to-struct
-compatible with data types produced by Clang when compiling C sources.
+In practical cases, it may be desirable to have externally-facing functions with
+a single attribute corresponding to a MemRef argument. When interfacing with
+LLVM IR produced from C, the code needs to respect the corresponding calling
+convention. The conversion to the LLVM dialect provides an option to generate
+wrapper functions that take memref descriptors as pointers-to-struct compatible
+with data types produced by Clang when compiling C sources. The generation of
+such wrapper functions can additionally be controlled at a function granularity
+by setting the `emit-c-interface` unit attribute.
 
 More specifically, a memref argument is converted into a pointer-to-struct
 argument of type `{T*, T*, i64, i64[N], i64[N]}*` in the wrapper function, where
 `T` is the converted element type and `N` is the memref rank. This type is
 compatible with that produced by Clang for the following C++ structure template
 instantiations or their equivalents in C.
 
 ```cpp

mlir/include/mlir/IR/Function.h

 //===- Function.h - MLIR Function Class -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   /// Returns the region on the current operation that is callable. This may
   /// return null in the case of an external callable object, e.g. an external
   /// function.
   Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
 
   /// Returns the results types that the callable region produces when executed.
   ArrayRef<Type> getCallableResults() { return getType().getResults(); }
 
+  //===--------------------------------------------------------------------===//
+  // Behavior controlled by attributes.
+  //===--------------------------------------------------------------------===//
+  bool emitCInterface();
+  void setEmitCInterface();
+
 private:
   // This trait needs access to the hooks defined below.
   friend class OpTrait::FunctionLike<FuncOp>;
 
   /// Returns the number of arguments. This is a hook for OpTrait::FunctionLike.
   unsigned getNumFuncArguments() { return getType().getInputs().size(); }
 
   /// Returns the number of results. This is a hook for OpTrait::FunctionLike.

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 //===- StandardToLLVM.cpp - Standard to LLVM dialect conversion -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
FuncOpConversion(LLVMTypeConverter &converter, bool emitCWrappers)
       : FuncOpConversionBase(converter), emitWrappers(emitCWrappers) {}
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto funcOp = cast<FuncOp>(op);
 
     auto newFuncOp = convertFuncOpToLLVMFuncOp(funcOp, rewriter);
-    if (emitWrappers) {
+    if (emitWrappers || funcOp.emitCInterface()) {
       if (newFuncOp.isExternal())
         wrapExternalFunction(rewriter, op->getLoc(), typeConverter, funcOp,
                              newFuncOp);
       else
         wrapForExternalCallers(rewriter, op->getLoc(), typeConverter, funcOp,
                                newFuncOp);
     }
 
LogicalResult LLVM::detail::oneToOneRewrite(
   }
   rewriter.replaceOp(op, results);
   return success();
 }
 
 ////////////// End Support for Lowering operations on n-D vectors //////////////
 namespace {
 template <typename SourceOp, unsigned OpCount>
 struct OpCountValidator {
   static_assert(
       std::is_base_of<
           typename OpTrait::NOperands<OpCount>::template Impl<SourceOp>,
           SourceOp>::value,
       "wrong operand count");
 };
 
 template <typename SourceOp>

mlir/lib/IR/Function.cpp

 //===- Function.cpp - MLIR Function Classes -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
FuncOp FuncOp::clone(BlockAndValueMapping &mapper) {
   /// Clone the current function into the new one and return it.
   cloneInto(newFunc, mapper);
   return newFunc;
 }
 FuncOp FuncOp::clone() {
   BlockAndValueMapping mapper;
   return clone(mapper);
 }
+
+//===--------------------------------------------------------------------===//
+// Attribute-supported behavior
+//===--------------------------------------------------------------------===//
+static constexpr StringLiteral kEmitInterfaceAttrName = "emit_c_interface";
+bool FuncOp::emitCInterface() { return !!getAttr(kEmitInterfaceAttrName); }
+void FuncOp::setEmitCInterface() {
+  setAttr(kEmitInterfaceAttrName, UnitAttr::get(getContext()));
+}

mlir/test/Conversion/StandardToLLVM/calling-convention.mlir

 // RUN: mlir-opt -convert-std-to-llvm='emit-c-wrappers=1' %s | FileCheck %s
+// RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE
 
 // This tests the default memref calling convention and the emission of C
 // wrappers. We don't need to separate runs because the wrapper-emission
 // version subsumes the calling convention and only adds new functions, that we
 // can also file-check in the same run.
 
 // An external function is transformed into the glue around calling an interface function.
 // CHECK-LABEL: @external
func @caller() {
 
   // Forward the values to the call.
   // CHECK: llvm.call @external(%[[ALLOC0]], %[[ALIGN0]], %[[OFFSET0]], %[[SIZE00]], %[[SIZE01]], %[[STRIDE00]], %[[STRIDE01]], %[[ALLOC1]], %[[ALIGN1]], %[[OFFSET1]]) : (!llvm<"float*">, !llvm<"float*">, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm<"float*">, !llvm<"float*">, !llvm.i64) -> ()
   call @external(%0#0, %0#1) : (memref<?x?xf32>, memref<f32>) -> ()
   return
 }
 
 // CHECK-LABEL: @callee
+// EMIT_C_ATTRIBUTE-LABEL: @callee
 func @callee(%arg0: memref<?xf32>, %arg1: index) {
   %0 = load %arg0[%arg1] : memref<?xf32>
   return
 }
 
 // Verify that an interface function is emitted.
 // CHECK-LABEL: @_mlir_ciface_callee
 // CHECK: %[[ARG0:.*]]: !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">
   // Load the memref descriptor pointer.
   // CHECK: %[[DESC:.*]] = llvm.load %[[ARG0]] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">
 
   // Extract individual components of the descriptor.
   // CHECK: %[[ALLOC:.*]] = llvm.extractvalue %[[DESC]][0]
   // CHECK: %[[ALIGN:.*]] = llvm.extractvalue %[[DESC]][1]
   // CHECK: %[[OFFSET:.*]] = llvm.extractvalue %[[DESC]][2]
   // CHECK: %[[SIZE:.*]] = llvm.extractvalue %[[DESC]][3, 0]
   // CHECK: %[[STRIDE:.*]] = llvm.extractvalue %[[DESC]][4, 0]
 
   // Forward the descriptor components to the call.
   // CHECK: llvm.call @callee(%[[ALLOC]], %[[ALIGN]], %[[OFFSET]], %[[SIZE]], %[[STRIDE]], %{{.*}}) : (!llvm<"float*">, !llvm<"float*">, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64) -> ()
 
+//   EMIT_C_ATTRIBUTE-NOT: @mlir_ciface_callee
+
+// CHECK-LABEL: @other_callee
+// EMIT_C_ATTRIBUTE-LABEL: @other_callee
+func @other_callee(%arg0: memref<?xf32>, %arg1: index) attributes { emit_c_interface } {
+  %0 = load %arg0[%arg1] : memref<?xf32>
+  return
+}
+
+// CHECK: @_mlir_ciface_other_callee
+// CHECK:   llvm.call @other_callee
+
+// EMIT_C_ATTRIBUTE: @_mlir_ciface_other_callee
+// EMIT_C_ATTRIBUTE:   llvm.call @other_callee