[mlir][func] Use internal linkage for C wrapper of external functions.

[ingomueller-net]

Summary

If a declaration of an externally defined function has the
llvm.emit_c_interface attribute, a wrapper function is created with
the same name that calls the corresponding function with the C interface
(which has the same name prefixed with _mlir_ciface_). This way, the
original code can use the non-C-interface under the original name but
call the C interface of the function transparently. However, until now,
that wrapper function was created with external linkage, so it would
collide if the library provided a (non-C-interface) function under the
original name. Since the wrapper is only needed for the current module,
it should, in fact, have internal linkage. This patch, thus, sets the
linkage of the function with the original name to internal unless the
linkage is set with the llvm.linkage attribute, in which case that is
used.

[ingomueller-net]

Abanding in favor of https://reviews.llvm.org/D153255.

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

filterFuncAttributes(
       attributes);
 
   // Create the auxiliary function.
   auto wrapperFunc = builder.create<LLVM::LLVMFuncOp>(
       loc, llvm::formatv("_mlir_ciface_{0}", funcOp.getName()).str(),
       wrapperType, LLVM::Linkage::External, /*dsoLocal*/ false,
       /*cconv*/ LLVM::CConv::C, attributes);
 
+  // Unless set explicitly in the original op, set the linkage of the new op to
+  // internal: this op used to be just a declaration to an externally defined
+  // function. The wrapper that we make out of it, however, should only be
+  // visible in this module.
+  if (!funcOp->hasAttr(linkageAttrName))
+    newFuncOp.setLinkage(LLVM::Linkage::Internal);
+
   builder.setInsertionPointToStart(newFuncOp.addEntryBlock());
 
   // Get a ValueRange containing arguments.
   FunctionType type = funcOp.getFunctionType();
   SmallVector<Value, 8> args;
   args.reserve(type.getNumInputs());
   ValueRange wrapperArgsRange(newFuncOp.getArguments());
 

mlir/test/Conversion/FuncToLLVM/emit-c-wrappers-for-external-functions.mlir

 // RUN: mlir-opt -llvm-request-c-wrappers -convert-func-to-llvm='use-opaque-pointers=1' %s | FileCheck %s
 
-// CHECK: llvm.func @res_attrs_with_memref_return() -> (!llvm.struct{{.*}} {test.returnOne})
+// CHECK: llvm.func internal @res_attrs_with_memref_return() -> (!llvm.struct{{.*}} {test.returnOne})
 // CHECK-LABEL: llvm.func @_mlir_ciface_res_attrs_with_memref_return
 // CHECK-SAME: !llvm.ptr
 // CHECK-NOT: test.returnOne
 func.func private @res_attrs_with_memref_return() -> (memref<f32> {test.returnOne})
 
-// CHECK: llvm.func @res_attrs_with_value_return() -> (f32 {test.returnOne = 1 : i64})
+// CHECK: llvm.func internal @res_attrs_with_value_return() -> (f32 {test.returnOne = 1 : i64})
 // CHECK-LABEL: llvm.func @_mlir_ciface_res_attrs_with_value_return
 // CHECK-SAME: -> (f32 {test.returnOne = 1 : i64})
 func.func private @res_attrs_with_value_return() -> (f32 {test.returnOne = 1})
 
-// CHECK: llvm.func @multiple_return() -> !llvm.struct<{{.*}}>
+// CHECK: llvm.func internal @multiple_return() -> !llvm.struct<{{.*}}>
 // CHECK-LABEL: llvm.func @_mlir_ciface_multiple_return
 // CHECK-NOT: test.returnOne
 // CHECK-NOT: test.returnTwo
 // CHECK-NOT: test.returnThree
 func.func private @multiple_return() -> (memref<f32> {test.returnOne = 1}, f32 {test.returnTwo = 2, test.returnThree = 3})
 
-// CHECK: llvm.func @multiple_return_missing_res_attr() -> !llvm.struct<{{.*}}>
+// CHECK: llvm.func internal @multiple_return_missing_res_attr() -> !llvm.struct<{{.*}}>
 // CHECK-LABEL: llvm.func @_mlir_ciface_multiple_return_missing_res_attr
 // CHECK-NOT: test.returnOne
 // CHECK-NOT: test.returnTwo
 // CHECK-NOT: test.returnThree
 func.func private @multiple_return_missing_res_attr() -> (memref<f32> {test.returnOne = 1}, i64, f32 {test.returnTwo = 2, test.returnThree = 3})
 
-// CHECK: llvm.func @one_arg_attr_no_res_attrs_with_memref_return({{.*}}) -> !llvm.struct{{.*}}
+// CHECK: llvm.func internal @one_arg_attr_no_res_attrs_with_memref_return({{.*}}) -> !llvm.struct{{.*}}
 // CHECK-LABEL: llvm.func @_mlir_ciface_one_arg_attr_no_res_attrs_with_memref_return
 // CHECK-SAME: !llvm.ptr
 // CHECK-SAME: !llvm.ptr
 // CHECK-SAME: {test.argOne = 1 : i64})
 func.func private @one_arg_attr_no_res_attrs_with_memref_return(%arg0: memref<f32> {test.argOne = 1}) -> memref<f32>
 
-// CHECK: llvm.func @one_arg_attr_one_res_attr_with_memref_return({{.*}}) -> (!llvm.struct<{{.*}}> {test.returnOne = 1 : i64})
+// CHECK: llvm.func internal @one_arg_attr_one_res_attr_with_memref_return({{.*}}) -> (!llvm.struct<{{.*}}> {test.returnOne = 1 : i64})
 // CHECK-LABEL: llvm.func @_mlir_ciface_one_arg_attr_one_res_attr_with_memref_return
 // CHECK-SAME: !llvm.ptr
 // CHECK-NOT: test.returnOne
 // CHECK-SAME: !llvm.ptr
 // CHECK-SAME: {test.argOne = 1 : i64})
 func.func private @one_arg_attr_one_res_attr_with_memref_return(%arg0: memref<f32> {test.argOne = 1}) -> (memref<f32> {test.returnOne = 1})
 
-// CHECK: llvm.func @one_arg_attr_one_res_attr_with_value_return({{.*}}) -> (f32 {test.returnOne = 1 : i64})
+// CHECK: llvm.func internal @one_arg_attr_one_res_attr_with_value_return({{.*}}) -> (f32 {test.returnOne = 1 : i64})
 // CHECK-LABEL: llvm.func @_mlir_ciface_one_arg_attr_one_res_attr_with_value_return
 // CHECK-SAME: !llvm.ptr
 // CHECK-SAME: {test.argOne = 1 : i64}
 // CHECK-SAME: -> (f32 {test.returnOne = 1 : i64})
 func.func private @one_arg_attr_one_res_attr_with_value_return(%arg0: memref<f32> {test.argOne = 1}) -> (f32 {test.returnOne = 1})
 
-// CHECK: llvm.func @multiple_arg_attr_multiple_res_attr({{.*}}) -> !llvm.struct<{{.*}}>
+// CHECK: llvm.func internal @multiple_arg_attr_multiple_res_attr({{.*}}) -> !llvm.struct<{{.*}}>
 // CHECK-LABEL: llvm.func @_mlir_ciface_multiple_arg_attr_multiple_res_attr
 // CHECK-SAME: !llvm.ptr
 // CHECK-NOT: test.returnOne
 // CHECK-NOT: test.returnTwo
 // CHECK-SAME: !llvm.ptr
 // CHECK-SAME: {test.argZero = 0 : i64}
 // CHECK-SAME: f32
 // CHECK-SAME: i32 {test.argTwo = 2 : i64})
 func.func private @multiple_arg_attr_multiple_res_attr(%arg0: memref<f32> {test.argZero = 0}, %arg1: f32, %arg2: i32 {test.argTwo = 2}) -> (f32, memref<i32> {test.returnOne = 1}, i32 {test.returnTwo = 2})
 
 // CHECK: llvm.func weak @drop_linkage_attr() -> (!llvm.struct{{.*}} {test.returnOne})
 // CHECK-LABEL: llvm.func @_mlir_ciface_drop_linkage_attr
 // CHECK-SAME: !llvm.ptr
 // CHECK-NOT: llvm.linkage
 func.func private @drop_linkage_attr() -> (memref<f32> {test.returnOne}) attributes { llvm.linkage = #llvm.linkage<weak> }