[mlir] Fix --convert-func-to-llvm=emit-c-wrappers argument and result attribute handling

[laszlo-luminous]

Summary

When using --convert-func-to-llvm=emit-c-wrappers the attribute arguments of the wrapper would not be created correctly in some cases.
This patch fixes that and introduces a set of tests for (hopefully) all corner cases.

See https://github.com/llvm/llvm-project/issues/53503

Author: Sam Carroll <[e-mail]>
Co-Author: Laszlo Kindrat <[e-mail]>

[laszlo-luminous]

Updated patch with context, and removed some trailing whitespaces

[mehdi_amini]

Sorry I missed this revision when it was sent out and I won't have time to get to it before next week.

@ftynse can you take care of it?

[ftynse]

LGTM in general, suggesting to add more verification.

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

69 ↗

(On Diff #409083)

I would rather put this into the LLVM dialect itself and have a verifier that checks if the attribute is well-formed (used in an op with FunctionOpInterface, the number of elements matches the number of struct elements).

86 ↗

(On Diff #409083)

Nit: drop the explicit number of SmallVector elements unless there is a strong reason to use a specific number.

[laszlo-luminous]

@ftynse I'm happy to add more verification and tests. Do you have any suggestions what they should cover?

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

86 ↗

(On Diff #409083)

I'll do that. I see that other functions in this file are also specifying the elements for SmallVector, but I can't immediately see why. Should I modify those as well?

[ftynse]

Do you have any suggestions what they should cover?

See my comment on line 69. MLIR has a mechanism to ensure that attributes with a name starting with the dialect name satisfy certain conditions -- dialect attribute verifiers. LLVM dialect already implements some here https://github.com/llvm/llvm-project/blob/da047445f77bfd74b04c36169e104f35dbfff84e/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp#L2536. What I suggest is to add your struct_atttribute in the list and check its well-formedness with respect to the operation it is attached to.

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

86 ↗

(On Diff #409083)

In most cases, they predate the default value for the number of stack elements in vectors. It would be helpful to clean them up in separate patches, thanks in advance!

[laszlo-luminous]

Ah okay, I misunderstood and thought you meant more unit tests by verification...

Anyway, I am almost done with the verifier for this attribute. However, should this verification happen in verifyRegionArgAttribute and verifyRegionResultAttribute, rather than verifyOperationAttribute? I'm not sure what the semantics are if it appears just as an op attribute (and if we should even allow that).

[ftynse]

The standard practice is to have a test for each user-visible error message, so adding a verifier mechanically requires adding more tests.

RegionArg/ResultVerifier are probably a better place for this if you are able to put the check there.

[laszlo-luminous]

Moved the llvm.struct_attrs attribute to the dialect, and added verifiers with tests.

[laszlo-luminous]

I think I addressed all points, see my inline comment about checking for FuncOpInterface.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

2665–2667

I'm not sure how I could test this. I found similar logic in https://github.com/llvm/llvm-project/blob/main/mlir/lib/Dialect/Linalg/IR/LinalgDialect.cpp#L132-L133 but I can't find tests for that.

[ftynse]

Thanks!

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

2655

Nit: start with the small case here like everywhere else.

[ftynse]

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

2665–2667

Just attach the attribute to any operation that doesn't implement the functionOpInterface, e.g. "addi".

[laszlo-luminous]

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

2665–2667

I have tried this:

func @invalid(%arg0 : i32, %arg1 : i32) {
  %0 = "arith.addi"(%arg0, %arg1) {llvm.struct_attrs} : (i32, i32) -> i32 
  return
}

which emits a different error, that I already have tests for:
error: 'scf.parallel' op 'llvm.struct_attrs' is permitted only in argument or result attributes

It seems that the only place where verifyRegionResultAttribute or verifyRegionArgAttribute is called is in the FunctionOpInterface verifier: https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/IR/FunctionInterfaces.h#L207
Which in turn means that this helper only ever gets called when a FunctionOpInterface is verified, so this error is never emitted. Or I'm misunderstanding something completely.

[laszlo-luminous]

fixed error message to start with lowercase

[laszlo-luminous]

Accidentally removed some tests, now they are back.

[laszlo-luminous]

Is there anything else I should fix on this?

[ftynse]

Please rebase on main and let me know if you need help landing this.

[laszlo-luminous]

Rebased on main.

[laszlo-luminous]

@ftynse Thanks for the review! I don't think I have permissions to commit, could you please help with that?

[laszlo-luminous]

Update with changes due to new func dialect

[laszlo-luminous]

@ftynse ping

[laszlo-luminous]

@mehdi_amini @ftynse Could you please help with committing this? Thanks!

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 // LLVM Dialect.
 //===----------------------------------------------------------------------===//
 
 def LLVM_Dialect : Dialect {
   let name = "llvm";
   let cppNamespace = "::mlir::LLVM";
 
   let hasRegionArgAttrVerify = 1;
+  let hasRegionResultAttrVerify = 1;
   let hasOperationAttrVerify = 1;
   let extraClassDeclaration = [{
     /// Name of the data layout attributes.
     static StringRef getDataLayoutAttrName() { return "llvm.data_layout"; }
     static StringRef getAlignAttrName() { return "llvm.align"; }
     static StringRef getNoAliasAttrName() { return "llvm.noalias"; }
     static StringRef getNoAliasScopesAttrName() { return "noalias_scopes"; }
     static StringRef getAliasScopesAttrName() { return "alias_scopes"; }
     static StringRef getLoopAttrName() { return "llvm.loop"; }
     static StringRef getParallelAccessAttrName() { return "parallel_access"; }
     static StringRef getLoopOptionsAttrName() { return "options"; }
     static StringRef getAccessGroupsAttrName() { return "access_groups"; }
+    static StringRef getStructAttrsAttrName() { return "llvm.struct_attrs"; }
+
+    /// Verifies if the attribute is a well-formed value for "llvm.struct_attrs"
+    static LogicalResult verifyStructAttr(
+        Operation *op, Attribute attr, Type annotatedType);
 
     /// Verifies if the given string is a well-formed data layout descriptor.
     /// Uses `reportError` to report errors.
     static LogicalResult verifyDataLayoutString(
         StringRef descr, llvm::function_ref<void (const Twine &)> reportError);
 
     /// Name of the target triple attribute.
     static StringRef getTargetTripleAttrName() { return "llvm.target_triple"; }

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FormatVariadic.h"
+#include <algorithm>
 #include <functional>
 
 using namespace mlir;
 
 #define PASS_NAME "convert-func-to-llvm"
 
 /// Only retain those attributes that are not constructed by
 /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
 /// attributes.
 static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs,
-                                 bool filterArgAttrs,
+                                 bool filterArgAndResAttrs,
                                  SmallVectorImpl<NamedAttribute> &result) {
   for (const auto &attr : attrs) {
     if (attr.getName() == SymbolTable::getSymbolAttrName() ||
         attr.getName() == FunctionOpInterface::getTypeAttrName() ||
         attr.getName() == "func.varargs" ||
-        (filterArgAttrs &&
-         attr.getName() == FunctionOpInterface::getArgDictAttrName()))
+        (filterArgAndResAttrs &&
+         (attr.getName() == FunctionOpInterface::getArgDictAttrName() ||
+          attr.getName() == FunctionOpInterface::getResultDictAttrName())))
       continue;
     result.push_back(attr);
   }
 }
 
+/// Helper function for wrapping all attributes into a single DictionaryAttr
+static auto wrapAsStructAttrs(OpBuilder &b, ArrayAttr attrs) {
+  return DictionaryAttr::get(
+      b.getContext(),
+      b.getNamedAttr(LLVM::LLVMDialect::getStructAttrsAttrName(), attrs));
+}
+
+/// Combines all result attributes into a single DictionaryAttr
+/// and prepends to argument attrs.
+/// This is intended to be used to format the attributes for a C wrapper
+/// function when the result(s) is converted to the first function argument
+/// (in the multiple return case, all returns get wrapped into a single
+/// argument). The total number of argument attributes should be equal to
+/// (number of function arguments) + 1.
+static void
+prependResAttrsToArgAttrs(OpBuilder &builder,
+                          SmallVectorImpl<NamedAttribute> &attributes,
+                          size_t numArguments) {
+  auto allAttrs = SmallVector<Attribute>(
+      numArguments + 1, DictionaryAttr::get(builder.getContext()));
+  NamedAttribute *argAttrs = nullptr;
+  for (auto it = attributes.begin(); it != attributes.end();) {
+    if (it->getName() == FunctionOpInterface::getArgDictAttrName()) {
+      auto arrayAttrs = it->getValue().cast<ArrayAttr>();
+      assert(arrayAttrs.size() == numArguments &&
+             "Number of arg attrs and args should match");
+      std::copy(arrayAttrs.begin(), arrayAttrs.end(), allAttrs.begin() + 1);
+      argAttrs = it;
+    } else if (it->getName() == FunctionOpInterface::getResultDictAttrName()) {
+      auto arrayAttrs = it->getValue().cast<ArrayAttr>();
+      assert(!arrayAttrs.empty() && "expected array to be non-empty");
+      allAttrs[0] = (arrayAttrs.size() == 1)
+                        ? arrayAttrs[0]
+                        : wrapAsStructAttrs(builder, arrayAttrs);
+      it = attributes.erase(it);
+      continue;
+    }
+    it++;
+  }
+
+  auto newArgAttrs =
+      builder.getNamedAttr(FunctionOpInterface::getArgDictAttrName(),
+                           builder.getArrayAttr(allAttrs));
+  if (!argAttrs) {
+    attributes.emplace_back(newArgAttrs);
+    return;
+  }
+  *argAttrs = newArgAttrs;
+  return;
+}
+
 /// Creates an auxiliary function with pointer-to-memref-descriptor-struct
 /// arguments instead of unpacked arguments. This function can be called from C
 /// by passing a pointer to a C struct corresponding to a memref descriptor.
 /// Similarly, returned memrefs are passed via pointers to a C struct that is
 /// passed as additional argument.
 /// Internally, the auxiliary function unpacks the descriptor into individual
 /// components and forwards them to `newFuncOp` and forwards the results to
 /// the extra arguments.
 static void wrapForExternalCallers(OpBuilder &rewriter, Location loc,
                                    LLVMTypeConverter &typeConverter,
                                    FuncOp funcOp, LLVM::LLVMFuncOp newFuncOp) {
   auto type = funcOp.getType();
   SmallVector<NamedAttribute, 4> attributes;
-  filterFuncAttributes(funcOp->getAttrs(), /*filterArgAttrs=*/false,
+  filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/false,
                        attributes);
   Type wrapperFuncType;
   bool resultIsNowArg;
   std::tie(wrapperFuncType, resultIsNowArg) =
       typeConverter.convertFunctionTypeCWrapper(type);
+  if (resultIsNowArg)
+    prependResAttrsToArgAttrs(rewriter, attributes, funcOp.getNumArguments());
   auto wrapperFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
       loc, llvm::formatv("_mlir_ciface_{0}", funcOp.getName()).str(),
       wrapperFuncType, LLVM::Linkage::External, /*dsoLocal*/ false, attributes);
 
   OpBuilder::InsertionGuard guard(rewriter);
   rewriter.setInsertionPointToStart(wrapperFuncOp.addEntryBlock());
 
   SmallVector<Value, 8> args;
static void wrapExternalFunction(OpBuilder &builder, Location loc,
   std::tie(wrapperType, resultIsNowArg) =
       typeConverter.convertFunctionTypeCWrapper(funcOp.getType());
   // This conversion can only fail if it could not convert one of the argument
   // types. But since it has been applied to a non-wrapper function before, it
   // should have failed earlier and not reach this point at all.
   assert(wrapperType && "unexpected type conversion failure");
 
   SmallVector<NamedAttribute, 4> attributes;
-  filterFuncAttributes(funcOp->getAttrs(), /*filterArgAttrs=*/false,
+  filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/false,
                        attributes);
 
+  if (resultIsNowArg)
+    prependResAttrsToArgAttrs(builder, attributes, funcOp.getNumArguments());
   // 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, attributes);
 
   builder.setInsertionPointToStart(newFuncOp.addEntryBlock());
 
   // Get a ValueRange containing arguments.
convertFuncOpToLLVMFuncOp(FuncOp funcOp,
     // LLVMTypeConverter provided to this legalization pattern.
     auto varargsAttr = funcOp->getAttrOfType<BoolAttr>("func.varargs");
     TypeConverter::SignatureConversion result(funcOp.getNumArguments());
     auto llvmType = getTypeConverter()->convertFunctionSignature(
         funcOp.getType(), varargsAttr && varargsAttr.getValue(), result);
     if (!llvmType)
       return nullptr;
 
-    // Propagate argument attributes to all converted arguments obtained after
-    // converting a given original argument.
+    // Propagate argument/result attributes to all converted arguments/result
+    // obtained after converting a given original argument/result.
     SmallVector<NamedAttribute, 4> attributes;
-    filterFuncAttributes(funcOp->getAttrs(), /*filterArgAttrs=*/true,
+    filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/true,
                          attributes);
+    if (ArrayAttr resAttrDicts = funcOp.getAllResultAttrs()) {
+      assert(!resAttrDicts.empty() && "expected array to be non-empty");
+      auto newResAttrDicts =
+          (funcOp.getNumResults() == 1)
+              ? resAttrDicts
+              : rewriter.getArrayAttr(
+                    {wrapAsStructAttrs(rewriter, resAttrDicts)});
+      attributes.push_back(rewriter.getNamedAttr(
+          FunctionOpInterface::getResultDictAttrName(), newResAttrDicts));
+    }
     if (ArrayAttr argAttrDicts = funcOp.getAllArgAttrs()) {
       SmallVector<Attribute, 4> newArgAttrs(
           llvmType.cast<LLVM::LLVMFunctionType>().getNumParams());
       for (unsigned i = 0, e = funcOp.getNumArguments(); i < e; ++i) {
         auto mapping = result.getInputMapping(i);
         assert(mapping.hasValue() &&
                "unexpected deletion of function argument");
         for (size_t j = 0; j < mapping->size; ++j)

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

Optional<NamedAttribute> loopOptions =
         loopAttr.getNamed(LLVMDialect::getLoopOptionsAttrName());
     if (loopOptions.hasValue() &&
         !loopOptions->getValue().isa<LoopOptionsAttr>())
       return op->emitOpError()
              << "expected '" << LLVMDialect::getLoopOptionsAttrName()
              << "' to be a `loopopts` attribute";
   }
 
+  if (attr.getName() == LLVMDialect::getStructAttrsAttrName()) {
+    return op->emitOpError()
+           << "'" << LLVM::LLVMDialect::getStructAttrsAttrName()
+           << "' is permitted only in argument or result attributes";
+  }
+
   // If the data layout attribute is present, it must use the LLVM data layout
   // syntax. Try parsing it and report errors in case of failure. Users of this
   // attribute may assume it is well-formed and can pass it to the (asserting)
   // llvm::DataLayout constructor.
   if (attr.getName() != LLVM::LLVMDialect::getDataLayoutAttrName())
     return success();
   if (auto stringAttr = attr.getValue().dyn_cast<StringAttr>())
     return verifyDataLayoutString(
         stringAttr.getValue(),
         [op](const Twine &message) { op->emitOpError() << message.str(); });
 
   return op->emitOpError() << "expected '"
                            << LLVM::LLVMDialect::getDataLayoutAttrName()
                            << "' to be a string attribute";
 }
 
+LogicalResult LLVMDialect::verifyStructAttr(Operation *op, Attribute attr,
+                                            Type annotatedType) {
+  auto structType = annotatedType.dyn_cast<LLVMStructType>();
+  if (!structType) {
+    const auto emitIncorrectAnnotatedType = [&op]() {
+      return op->emitError()
+             << "expected '" << LLVMDialect::getStructAttrsAttrName()
+             << "' to annotate '!llvm.struct' or '!llvm.ptr<struct<...>>'";
+    };
+    const auto ptrType = annotatedType.dyn_cast<LLVMPointerType>();
+    if (!ptrType)
+      return emitIncorrectAnnotatedType();
+    structType = ptrType.getElementType().dyn_cast<LLVMStructType>();
+    if (!structType)
+      return emitIncorrectAnnotatedType();
+  }
+
+  const auto arrAttrs = attr.dyn_cast<ArrayAttr>();
+  if (!arrAttrs)
+    return op->emitError() << "expected '"
+                           << LLVMDialect::getStructAttrsAttrName()
+                           << "' to be an array attribute";
+
+  if (structType.getBody().size() != arrAttrs.size())
+    return op->emitError()
+           << "size of '" << LLVMDialect::getStructAttrsAttrName()
+           << "' must match the size of the annotated '!llvm.struct'";
+  return success();
+}
+
+static LogicalResult verifyFuncOpInterfaceStructAttr(
+    Operation *op, Attribute attr,
+    std::function<Type(FunctionOpInterface)> getAnnotatedType) {
+  if (auto funcOp = dyn_cast<FunctionOpInterface>(op))
+    return LLVMDialect::verifyStructAttr(op, attr, getAnnotatedType(funcOp));
+  return op->emitError() << "expected '"
+                         << LLVMDialect::getStructAttrsAttrName()
+                         << "' to be used on function-like operations";
+}
+
 /// Verify LLVMIR function argument attributes.
 LogicalResult LLVMDialect::verifyRegionArgAttribute(Operation *op,
                                                     unsigned regionIdx,
                                                     unsigned argIdx,
                                                     NamedAttribute argAttr) {
   // Check that llvm.noalias is a unit attribute.
   if (argAttr.getName() == LLVMDialect::getNoAliasAttrName() &&
       !argAttr.getValue().isa<UnitAttr>())
     return op->emitError()
            << "expected llvm.noalias argument attribute to be a unit attribute";
   // Check that llvm.align is an integer attribute.
   if (argAttr.getName() == LLVMDialect::getAlignAttrName() &&
       !argAttr.getValue().isa<IntegerAttr>())
     return op->emitError()
            << "llvm.align argument attribute of non integer type";
+  if (argAttr.getName() == LLVMDialect::getStructAttrsAttrName()) {
+    return verifyFuncOpInterfaceStructAttr(
+        op, argAttr.getValue(), [argIdx](FunctionOpInterface funcOp) {
+          return funcOp.getArgumentTypes()[argIdx];
+        });
+  }
+  return success();
+}
+
+LogicalResult LLVMDialect::verifyRegionResultAttribute(Operation *op,
+                                                       unsigned regionIdx,
+                                                       unsigned resIdx,
+                                                       NamedAttribute resAttr) {
+  if (resAttr.getName() == LLVMDialect::getStructAttrsAttrName()) {
+    return verifyFuncOpInterfaceStructAttr(
+        op, resAttr.getValue(), [resIdx](FunctionOpInterface funcOp) {
+          return funcOp.getResultTypes()[resIdx];
+        });
+  }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 Value mlir::LLVM::createGlobalString(Location loc, OpBuilder &builder,

mlir/test/Conversion/StandardToLLVM/emit-c-wrappers-for-external-callers.mlir

+// RUN: mlir-opt -convert-func-to-llvm='emit-c-wrappers=1' %s | FileCheck %s
+
+// CHECK: llvm.func @res_attrs_with_memref_return() -> (!llvm.struct{{.*}} {test.returnOne})
+// CHECK-LABEL: llvm.func @_mlir_ciface_res_attrs_with_memref_return
+// CHECK: %{{.*}}: !llvm.ptr{{.*}} {test.returnOne}
+func @res_attrs_with_memref_return() -> (memref<f32> {test.returnOne}) {
+  %0 = memref.alloc() : memref<f32>
+  return %0 : memref<f32>
+}
+
+// CHECK: llvm.func @res_attrs_with_value_return() -> (f32 {test.returnOne = 1 : i64})
+// CHECK-LABEL: llvm.func @_mlir_ciface_res_attrs_with_value_return
+// CHECK: -> (f32 {test.returnOne = 1 : i64})
+func @res_attrs_with_value_return() -> (f32 {test.returnOne = 1}) {
+  %0 = arith.constant 1.00 : f32
+  return %0 : f32
+}
+
+// CHECK: llvm.func @multiple_return() -> (!llvm.struct<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+// CHECK-LABEL: llvm.func @_mlir_ciface_multiple_return
+// CHECK: (%{{.*}}: !llvm.ptr<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+func @multiple_return() -> (memref<f32> {test.returnOne = 1}, f32 {test.returnTwo = 2, test.returnThree = 3}) {
+  %0 = memref.alloc() : memref<f32>
+  %1 = arith.constant 1.00 : f32
+  return %0, %1 : memref<f32>, f32
+}
+
+// CHECK: llvm.func @multiple_return_missing_res_attr() -> (!llvm.struct<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+// CHECK-LABEL: llvm.func @_mlir_ciface_multiple_return_missing_res_attr
+// CHECK: (%{{.*}}: !llvm.ptr<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+func @multiple_return_missing_res_attr() -> (memref<f32> {test.returnOne = 1}, i64, f32 {test.returnTwo = 2, test.returnThree = 3}) {
+  %0 = memref.alloc() : memref<f32>
+  %1 = arith.constant 2 : i64
+  %2 = arith.constant 1.00 : f32
+  return %0, %1, %2 : memref<f32>, i64, f32
+}
+
+// CHECK: llvm.func @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: %{{.*}}: !llvm.ptr<{{.*}}>, %{{.*}}: !llvm.ptr<{{.*}}> {test.argOne = 1 : i64}
+func @one_arg_attr_no_res_attrs_with_memref_return(%arg0: memref<f32> {test.argOne = 1}) -> memref<f32> {
+  %0 = memref.alloc() : memref<f32>
+  return %0 : memref<f32>
+}
+
+// CHECK: llvm.func @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: (%{{.*}}: !llvm.ptr<{{.*}}> {test.returnOne = 1 : i64}, %{{.*}}: !llvm.ptr<{{.*}}> {test.argOne = 1 : i64}
+func @one_arg_attr_one_res_attr_with_memref_return(%arg0: memref<f32> {test.argOne = 1}) -> (memref<f32> {test.returnOne = 1}) {
+  %0 = memref.alloc() : memref<f32>
+  return %0 : memref<f32>
+}
+
+// CHECK: llvm.func @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: (%{{.*}}: !llvm.ptr<{{.*}}> {test.argOne = 1 : i64}) -> (f32 {test.returnOne = 1 : i64})
+func @one_arg_attr_one_res_attr_with_value_return(%arg0: memref<f32> {test.argOne = 1}) -> (f32 {test.returnOne = 1}) {
+  %0 = arith.constant 1.00 : f32
+  return %0 : f32
+}
+
+// CHECK: llvm.func @multiple_arg_attr_multiple_res_attr({{.*}}) -> (!llvm.struct<{{.*}}> {llvm.struct_attrs = [{}, {test.returnOne = 1 : i64}, {test.returnTwo = 2 : i64}]})
+// CHECK-LABEL: llvm.func @_mlir_ciface_multiple_arg_attr_multiple_res_attr
+// CHECK: (%{{.*}}: !llvm.ptr<{{.*}}> {llvm.struct_attrs = [{}, {test.returnOne = 1 : i64}, {test.returnTwo = 2 : i64}]}, %{{.*}}: !llvm.ptr<{{.*}}> {test.argZero = 0 : i64}, %{{.*}}: f32, %{{.*}}: i32 {test.argTwo = 2 : i64}
+func @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}) {
+  %0 = arith.constant 1.00 : f32
+  %1 = memref.alloc() : memref<i32>
+  %2 = arith.constant 2 : i32
+  return %0, %1, %2 : f32, memref<i32>, i32
+}

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

+// RUN: mlir-opt -convert-func-to-llvm='emit-c-wrappers=1' %s | FileCheck %s
+
+// CHECK: llvm.func @res_attrs_with_memref_return() -> (!llvm.struct{{.*}} {test.returnOne})
+// CHECK-LABEL: llvm.func @_mlir_ciface_res_attrs_with_memref_return
+// CHECK: !llvm.ptr{{.*}} {test.returnOne}
+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-LABEL: llvm.func @_mlir_ciface_res_attrs_with_value_return
+// CHECK: -> (f32 {test.returnOne = 1 : i64})
+func private @res_attrs_with_value_return() -> (f32 {test.returnOne = 1})
+
+// CHECK: llvm.func @multiple_return() -> (!llvm.struct<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+// CHECK-LABEL: llvm.func @_mlir_ciface_multiple_return
+// CHECK: (!llvm.ptr<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+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<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+// CHECK-LABEL: llvm.func @_mlir_ciface_multiple_return_missing_res_attr
+// CHECK: (!llvm.ptr<{{.*}}> {llvm.struct_attrs = [{test.returnOne = 1 : i64}, {}, {test.returnThree = 3 : i64, test.returnTwo = 2 : i64}]})
+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-LABEL: llvm.func @_mlir_ciface_one_arg_attr_no_res_attrs_with_memref_return
+// CHECK: !llvm.ptr<{{.*}}>, !llvm.ptr<{{.*}}> {test.argOne = 1 : i64}
+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-LABEL: llvm.func @_mlir_ciface_one_arg_attr_one_res_attr_with_memref_return
+// CHECK: (!llvm.ptr<{{.*}}> {test.returnOne = 1 : i64}, !llvm.ptr<{{.*}}> {test.argOne = 1 : i64}
+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-LABEL: llvm.func @_mlir_ciface_one_arg_attr_one_res_attr_with_value_return
+// CHECK: (!llvm.ptr<{{.*}}> {test.argOne = 1 : i64}) -> (f32 {test.returnOne = 1 : i64})
+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<{{.*}}> {llvm.struct_attrs = [{}, {test.returnOne = 1 : i64}, {test.returnTwo = 2 : i64}]})
+// CHECK-LABEL: llvm.func @_mlir_ciface_multiple_arg_attr_multiple_res_attr
+// CHECK: (!llvm.ptr<{{.*}}> {llvm.struct_attrs = [{}, {test.returnOne = 1 : i64}, {test.returnTwo = 2 : i64}]}, !llvm.ptr<{{.*}}> {test.argZero = 0 : i64}, f32, i32 {test.argTwo = 2 : i64}
+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})

mlir/test/Dialect/LLVMIR/func.mlir

module {
   }
 
   // Omit the `external` linkage, which is the default, in the custom format.
   // Check that it is present in the generic format using its numeric value.
   //
   // CHECK: llvm.func @external_func
   // GENERIC: linkage = #llvm.linkage<external>
   llvm.func external @external_func()
+
+  // CHECK-LABEL: llvm.func @arg_struct_attr(
+  // CHECK-SAME: %{{.*}}: !llvm.struct<(i32)> {llvm.struct_attrs = [{llvm.noalias}]}) {
+  llvm.func @arg_struct_attr(
+      %arg0 : !llvm.struct<(i32)> {llvm.struct_attrs = [{llvm.noalias}]}) {
+    llvm.return
+  }
+
+   // CHECK-LABEL: llvm.func @res_struct_attr(%{{.*}}: !llvm.struct<(i32)>)
+   // CHECK-SAME:-> (!llvm.struct<(i32)> {llvm.struct_attrs = [{llvm.noalias}]}) {
+  llvm.func @res_struct_attr(%arg0 : !llvm.struct<(i32)>)
+      -> (!llvm.struct<(i32)> {llvm.struct_attrs = [{llvm.noalias}]}) {
+    llvm.return %arg0 : !llvm.struct<(i32)>
+  }
 }
 
 // -----
 
 module {
   // expected-error@+1 {{requires one region}}
   "llvm.func"() {sym_name = "no_region", type = !llvm.func<void ()>} : () -> ()
 }

mlir/test/Dialect/LLVMIR/invalid.mlir

 
 llvm.mlir.global internal @side_effecting_global() : !llvm.struct<(i8)> {
   %0 = llvm.mlir.constant(1 : i64) : i64
   // expected-error@below {{ops with side effects not allowed in global initializers}}
   %1 = llvm.alloca %0 x !llvm.struct<(i8)> : (i64) -> !llvm.ptr<struct<(i8)>>
   %2 = llvm.load %1 : !llvm.ptr<struct<(i8)>>
   llvm.return %2 : !llvm.struct<(i8)>
 }
+
+// -----
+
+// expected-error@+1 {{'llvm.struct_attrs' is permitted only in argument or result attributes}}
+func @struct_attrs_in_op() attributes {llvm.struct_attrs = []} {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{expected 'llvm.struct_attrs' to annotate '!llvm.struct' or '!llvm.ptr<struct<...>>'}}
+func @invalid_struct_attr_arg_type(%arg0 : i32 {llvm.struct_attrs = []}) {
+    return
+}
+
+// -----
+
+// expected-error@+1 {{expected 'llvm.struct_attrs' to annotate '!llvm.struct' or '!llvm.ptr<struct<...>>'}}
+func @invalid_struct_attr_pointer_arg_type(%arg0 : !llvm.ptr<i32> {llvm.struct_attrs = []}) {
+    return
+}
+
+// -----
+
+// expected-error@+1 {{expected 'llvm.struct_attrs' to be an array attribute}}
+func @invalid_arg_struct_attr_value(%arg0 : !llvm.struct<(i32)> {llvm.struct_attrs = {}}) {
+    return
+}
+
+// -----
+
+// expected-error@+1 {{size of 'llvm.struct_attrs' must match the size of the annotated '!llvm.struct'}}
+func @invalid_arg_struct_attr_size(%arg0 : !llvm.struct<(i32)> {llvm.struct_attrs = []}) {
+    return
+}
+
+// -----
+
+// expected-error@+1 {{expected 'llvm.struct_attrs' to annotate '!llvm.struct' or '!llvm.ptr<struct<...>>'}}
+func @invalid_struct_attr_res_type(%arg0 : i32) -> (i32 {llvm.struct_attrs = []}) {
+  return %arg0 : i32
+}
+
+// -----
+
+// expected-error@+1 {{expected 'llvm.struct_attrs' to annotate '!llvm.struct' or '!llvm.ptr<struct<...>>'}}
+func @invalid_struct_attr_pointer_res_type(%arg0 : !llvm.ptr<i32>) -> (!llvm.ptr<i32> {llvm.struct_attrs = []}) {
+    return %arg0 : !llvm.ptr<i32>
+}
+
+// -----
+
+// expected-error@+1 {{expected 'llvm.struct_attrs' to be an array attribute}}
+func @invalid_res_struct_attr_value(%arg0 : !llvm.struct<(i32)>) -> (!llvm.struct<(i32)> {llvm.struct_attrs = {}}) {
+    return %arg0 : !llvm.struct<(i32)>
+}
+
+// -----
+
+// expected-error@+1 {{size of 'llvm.struct_attrs' must match the size of the annotated '!llvm.struct'}}
+func @invalid_res_struct_attr_size(%arg0 : !llvm.struct<(i32)>) -> (!llvm.struct<(i32)> {llvm.struct_attrs = []}) {
+    return %arg0 : !llvm.struct<(i32)>
+}