[mlir][llvmir] Convert attributes for functions without bodies.

[vzakhari]

Summary

So far the function argument attributes were only translated
for functions with bodies. This change makes sure that this
happens for functions without bodies (declarations) as well.

This is needed for https://github.com/llvm/llvm-project/issues/58579

[ftynse]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

893–895

Nit: can this use C++17-style structured bindings (aka tuple unpacking) in the loop instead?

[vzakhari]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

893–895

Thanks! Yes, we can use it. I will upload the updated file shortly (with a rebase - sorry for the inconvenience).

[vzakhari]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

829–830

Used structured binding here.

893

Used structured binding here.

flang/test/Fir/target.fir

func.func @gen8() -> !fir.complex<8> {
   // I64: store { double, double } { double -4.000000e+00, double 1.000000e+00 }
   // I64: %[[load:.*]] = load { double, double }
   // I64: ret { double, double } %[[load]]
   // AARCH64: ret { double, double }
   // PPC: ret { double, double }
   return %5 : !fir.complex<8>
 }
 
-// I32: declare void @sink4(ptr)
+// I32: declare void @sink4(ptr byval({ float, float }) align 4)
 // X64: declare void @sink4(<2 x float>)
 // AARCH64: declare void @sink4([2 x float])
 // PPC: declare void @sink4(float, float)
 func.func private @sink4(!fir.complex<4>) -> ()
 
-// I32: declare void @sink8(ptr)
+// I32: declare void @sink8(ptr byval({ double, double }) align 4)
 // X64: declare void @sink8(double, double)
 // AARCH64: declare void @sink8([2 x double])
 // PPC: declare void @sink8(double, double)
 func.func private @sink8(!fir.complex<8>) -> ()
 
 // I32-LABEL: define void @call4()
 // X64-LABEL: define void @call4()
 // AARCH64-LABEL: define void @call4()

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
   valueMapping.clear();
   branchMapping.clear();
   llvm::Function *llvmFunc = lookupFunction(func.getName());
 
   // Translate the debug information for this function.
   debugTranslation->translate(func, *llvmFunc);
 
   // Add function arguments to the value remapping table.
-  // If there was noalias info then we decorate each argument accordingly.
-  unsigned int argIdx = 0;
-  for (auto kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
-    llvm::Argument &llvmArg = std::get<1>(kvp);
-    BlockArgument mlirArg = std::get<0>(kvp);
+  for (auto [mlirArg, llvmArg] :
+       llvm::zip(func.getArguments(), llvmFunc->args()))
+    mapValue(mlirArg, &llvmArg);
+
+  // Check the personality and set it.
+  if (func.getPersonality()) {
+    llvm::Type *ty = llvm::Type::getInt8PtrTy(llvmFunc->getContext());
+    if (llvm::Constant *pfunc = getLLVMConstant(ty, func.getPersonalityAttr(),
+                                                func.getLoc(), *this))
+      llvmFunc->setPersonalityFn(pfunc);
+  }
+
+  if (auto gc = func.getGarbageCollector())
+    llvmFunc->setGC(gc->str());
 
-    if (auto attr = func.getArgAttrOfType<UnitAttr>(
+  // First, create all blocks so we can jump to them.
+  llvm::LLVMContext &llvmContext = llvmFunc->getContext();
+  for (auto &bb : func) {
+    auto *llvmBB = llvm::BasicBlock::Create(llvmContext);
+    llvmBB->insertInto(llvmFunc);
+    mapBlock(&bb, llvmBB);
+  }
+
+  // Then, convert blocks one by one in topological order to ensure defs are
+  // converted before uses.
+  auto blocks = detail::getTopologicallySortedBlocks(func.getBody());
+  for (Block *bb : blocks) {
+    llvm::IRBuilder<> builder(llvmContext);
+    if (failed(convertBlock(*bb, bb->isEntryBlock(), builder)))
+      return failure();
+  }
+
+  // After all blocks have been traversed and values mapped, connect the PHI
+  // nodes to the results of preceding blocks.
+  detail::connectPHINodes(func.getBody(), *this);
+
+  // Finally, convert dialect attributes attached to the function.
+  return convertDialectAttributes(func);
+}
+
+LogicalResult ModuleTranslation::convertDialectAttributes(Operation *op) {
+  for (NamedAttribute attribute : op->getDialectAttrs())
+    if (failed(iface.amendOperation(op, attribute, *this)))
+      return failure();
+  return success();
+}
+
+LogicalResult ModuleTranslation::convertFunctionSignatures() {
+  // Declare all functions first because there may be function calls that form a
+  // call graph with cycles, or global initializers that reference functions.
+  for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
+    llvm::FunctionCallee llvmFuncCst = llvmModule->getOrInsertFunction(
+        function.getName(),
+        cast<llvm::FunctionType>(convertType(function.getFunctionType())));
+    llvm::Function *llvmFunc = cast<llvm::Function>(llvmFuncCst.getCallee());
+    llvmFunc->setLinkage(convertLinkageToLLVM(function.getLinkage()));
+    mapFunction(function.getName(), llvmFunc);
+    addRuntimePreemptionSpecifier(function.getDsoLocal(), llvmFunc);
+
+    if (function->getAttrOfType<UnitAttr>(LLVMDialect::getReadnoneAttrName()))
+      llvmFunc->setDoesNotAccessMemory();
+
+    // Convert argument attributes.
+    unsigned int argIdx = 0;
+    for (auto [mlirArgTy, llvmArg] :
+         llvm::zip(function.getArgumentTypes(), llvmFunc->args())) {
+      if (auto attr = function.getArgAttrOfType<UnitAttr>(
               argIdx, LLVMDialect::getNoAliasAttrName())) {
-      // NB: Attribute already verified to be boolean, so check if we can indeed
-      // attach the attribute to this argument, based on its type.
-      auto argTy = mlirArg.getType();
-      if (!argTy.isa<LLVM::LLVMPointerType>())
-        return func.emitError(
+        // NB: Attribute already verified to be boolean, so check if we can
+        // indeed attach the attribute to this argument, based on its type.
+        if (!mlirArgTy.isa<LLVM::LLVMPointerType>())
+          return function.emitError(
               "llvm.noalias attribute attached to LLVM non-pointer argument");
         llvmArg.addAttr(llvm::Attribute::AttrKind::NoAlias);
       }
 
-    if (auto attr = func.getArgAttrOfType<IntegerAttr>(
+      if (auto attr = function.getArgAttrOfType<IntegerAttr>(
               argIdx, LLVMDialect::getAlignAttrName())) {
         // NB: Attribute already verified to be int, so check if we can indeed
         // attach the attribute to this argument, based on its type.
-      auto argTy = mlirArg.getType();
-      if (!argTy.isa<LLVM::LLVMPointerType>())
-        return func.emitError(
+        if (!mlirArgTy.isa<LLVM::LLVMPointerType>())
+          return function.emitError(
               "llvm.align attribute attached to LLVM non-pointer argument");
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addAlignmentAttr(llvm::Align(attr.getInt())));
       }
 
-    if (auto attr = func.getArgAttrOfType<TypeAttr>(
+      if (auto attr = function.getArgAttrOfType<TypeAttr>(
               argIdx, LLVMDialect::getStructRetAttrName())) {
-      auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMPointerType>();
+        auto argTy = mlirArgTy.dyn_cast<LLVM::LLVMPointerType>();
         if (!argTy)
-        return func.emitError(
+          return function.emitError(
               "llvm.sret attribute attached to LLVM non-pointer argument");
         if (!argTy.isOpaque() && argTy.getElementType() != attr.getValue())
-        return func.emitError("llvm.sret attribute attached to LLVM pointer "
-                              "argument of a different type");
+          return function.emitError(
+              "llvm.sret attribute attached to LLVM pointer "
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addStructRetAttr(convertType(attr.getValue())));
       }
 
-    if (auto attr = func.getArgAttrOfType<TypeAttr>(
+      if (auto attr = function.getArgAttrOfType<TypeAttr>(
               argIdx, LLVMDialect::getByValAttrName())) {
-      auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMPointerType>();
+        auto argTy = mlirArgTy.dyn_cast<LLVM::LLVMPointerType>();
         if (!argTy)
-        return func.emitError(
+          return function.emitError(
               "llvm.byval attribute attached to LLVM non-pointer argument");
         if (!argTy.isOpaque() && argTy.getElementType() != attr.getValue())
-        return func.emitError("llvm.byval attribute attached to LLVM pointer "
-                              "argument of a different type");
+          return function.emitError(
+              "llvm.byval attribute attached to LLVM pointer "
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addByValAttr(convertType(attr.getValue())));
       }
 
-    if (auto attr = func.getArgAttrOfType<TypeAttr>(
+      if (auto attr = function.getArgAttrOfType<TypeAttr>(
               argIdx, LLVMDialect::getByRefAttrName())) {
-      auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMPointerType>();
+        auto argTy = mlirArgTy.dyn_cast<LLVM::LLVMPointerType>();
         if (!argTy)
-        return func.emitError(
+          return function.emitError(
               "llvm.byref attribute attached to LLVM non-pointer argument");
         if (!argTy.isOpaque() && argTy.getElementType() != attr.getValue())
-        return func.emitError("llvm.byref attribute attached to LLVM pointer "
-                              "argument of a different type");
+          return function.emitError(
+              "llvm.byref attribute attached to LLVM pointer "
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addByRefAttr(convertType(attr.getValue())));
       }
 
-    if (auto attr = func.getArgAttrOfType<TypeAttr>(
+      if (auto attr = function.getArgAttrOfType<TypeAttr>(
               argIdx, LLVMDialect::getInAllocaAttrName())) {
-      auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMPointerType>();
+        auto argTy = mlirArgTy.dyn_cast<LLVM::LLVMPointerType>();
         if (!argTy)
-        return func.emitError(
+          return function.emitError(
               "llvm.inalloca attribute attached to LLVM non-pointer argument");
         if (!argTy.isOpaque() && argTy.getElementType() != attr.getValue())
-        return func.emitError(
+          return function.emitError(
               "llvm.inalloca attribute attached to LLVM pointer "
               "argument of a different type");
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addInAllocaAttr(convertType(attr.getValue())));
       }
 
-    if (auto attr = func.getArgAttrOfType<UnitAttr>(argIdx, "llvm.nest")) {
-      auto argTy = mlirArg.getType();
-      if (!argTy.isa<LLVM::LLVMPointerType>())
-        return func.emitError(
+      if (auto attr =
+              function.getArgAttrOfType<UnitAttr>(argIdx, "llvm.nest")) {
+        if (!mlirArgTy.isa<LLVM::LLVMPointerType>())
+          return function.emitError(
               "llvm.nest attribute attached to LLVM non-pointer argument");
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addAttribute(llvm::Attribute::Nest));
       }
 
-    if (auto attr = func.getArgAttrOfType<UnitAttr>(
+      if (auto attr = function.getArgAttrOfType<UnitAttr>(
               argIdx, LLVMDialect::getNoUndefAttrName())) {
         // llvm.noundef can be added to any argument type.
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addAttribute(llvm::Attribute::NoUndef));
       }
-
-    mapValue(mlirArg, &llvmArg);
-    argIdx++;
-  }
-
-  // Check the personality and set it.
-  if (func.getPersonality()) {
-    llvm::Type *ty = llvm::Type::getInt8PtrTy(llvmFunc->getContext());
-    if (llvm::Constant *pfunc = getLLVMConstant(ty, func.getPersonalityAttr(),
-                                                func.getLoc(), *this))
-      llvmFunc->setPersonalityFn(pfunc);
-  }
-
-  if (auto gc = func.getGarbageCollector())
-    llvmFunc->setGC(gc->str());
-
-  // First, create all blocks so we can jump to them.
-  llvm::LLVMContext &llvmContext = llvmFunc->getContext();
-  for (auto &bb : func) {
-    auto *llvmBB = llvm::BasicBlock::Create(llvmContext);
-    llvmBB->insertInto(llvmFunc);
-    mapBlock(&bb, llvmBB);
-  }
-
-  // Then, convert blocks one by one in topological order to ensure defs are
-  // converted before uses.
-  auto blocks = detail::getTopologicallySortedBlocks(func.getBody());
-  for (Block *bb : blocks) {
-    llvm::IRBuilder<> builder(llvmContext);
-    if (failed(convertBlock(*bb, bb->isEntryBlock(), builder)))
-      return failure();
+      ++argIdx;
     }
 
-  // After all blocks have been traversed and values mapped, connect the PHI
-  // nodes to the results of preceding blocks.
-  detail::connectPHINodes(func.getBody(), *this);
-
-  // Finally, convert dialect attributes attached to the function.
-  return convertDialectAttributes(func);
-}
-
-LogicalResult ModuleTranslation::convertDialectAttributes(Operation *op) {
-  for (NamedAttribute attribute : op->getDialectAttrs())
-    if (failed(iface.amendOperation(op, attribute, *this)))
-      return failure();
-  return success();
-}
-
-LogicalResult ModuleTranslation::convertFunctionSignatures() {
-  // Declare all functions first because there may be function calls that form a
-  // call graph with cycles, or global initializers that reference functions.
-  for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
-    llvm::FunctionCallee llvmFuncCst = llvmModule->getOrInsertFunction(
-        function.getName(),
-        cast<llvm::FunctionType>(convertType(function.getFunctionType())));
-    llvm::Function *llvmFunc = cast<llvm::Function>(llvmFuncCst.getCallee());
-    llvmFunc->setLinkage(convertLinkageToLLVM(function.getLinkage()));
-    mapFunction(function.getName(), llvmFunc);
-    addRuntimePreemptionSpecifier(function.getDsoLocal(), llvmFunc);
-
-    if (function->getAttrOfType<UnitAttr>(LLVMDialect::getReadnoneAttrName()))
-      llvmFunc->setDoesNotAccessMemory();
-
     // Forward the pass-through attributes to LLVM.
     if (failed(forwardPassthroughAttributes(
             function.getLoc(), function.getPassthrough(), llvmFunc)))
       return failure();
   }
 
   return success();
 }

mlir/test/Dialect/LLVMIR/func.mlir

llvm.func @sretattr(%arg0: !llvm.ptr<i32> {llvm.sret = i32} loc("some_source_loc")) {
     llvm.return
   }
 
   // CHECK: llvm.func @nestattr(%{{.*}}: !llvm.ptr<i32> {llvm.nest})
   llvm.func @nestattr(%arg0: !llvm.ptr<i32> {llvm.nest}) {
     llvm.return
   }
 
+  // CHECK: llvm.func @llvm_noalias_decl(!llvm.ptr<f32> {llvm.noalias})
+  llvm.func @llvm_noalias_decl(!llvm.ptr<f32> {llvm.noalias})
+  // CHECK: llvm.func @byrefattr_decl(!llvm.ptr<i32> {llvm.byref = i32})
+  llvm.func @byrefattr_decl(!llvm.ptr<i32> {llvm.byref = i32})
+  // CHECK: llvm.func @byvalattr_decl(!llvm.ptr<i32> {llvm.byval = i32})
+  llvm.func @byvalattr_decl(!llvm.ptr<i32> {llvm.byval = i32})
+  // CHECK: llvm.func @sretattr_decl(!llvm.ptr<i32> {llvm.sret = i32})
+  llvm.func @sretattr_decl(!llvm.ptr<i32> {llvm.sret = i32})
+  // CHECK: llvm.func @nestattr_decl(!llvm.ptr<i32> {llvm.nest})
+  llvm.func @nestattr_decl(!llvm.ptr<i32> {llvm.nest})
+  // CHECK: llvm.func @noundefattr_decl(i32 {llvm.noundef})
+  llvm.func @noundefattr_decl(i32 {llvm.noundef})
+  // CHECK: llvm.func @llvm_align_decl(!llvm.ptr<f32> {llvm.align = 4 : i64})
+  llvm.func @llvm_align_decl(!llvm.ptr<f32> {llvm.align = 4})
+  // CHECK: llvm.func @inallocaattr_decl(!llvm.ptr<i32> {llvm.inalloca = i32})
+  llvm.func @inallocaattr_decl(!llvm.ptr<i32> {llvm.inalloca = i32})
+
+
   // CHECK: llvm.func @variadic(...)
   llvm.func @variadic(...)
 
   // CHECK: llvm.func @variadic_args(i32, i32, ...)
   llvm.func @variadic_args(i32, i32, ...)
 
   //
   // Check that functions can have linkage attributes.

mlir/test/Target/LLVMIR/llvmir.mlir

// CHECK-NEXT:   br label %3
   llvm.br ^bb1(%arg1 : i1)
 }
 
 // CHECK-LABEL: define void @llvm_noalias(ptr noalias {{%*.}})
 llvm.func @llvm_noalias(%arg0: !llvm.ptr<f32> {llvm.noalias}) {
   llvm.return
 }
 
+// CHECK-LABEL: declare void @llvm_noalias_decl(ptr noalias)
+llvm.func @llvm_noalias_decl(!llvm.ptr<f32> {llvm.noalias})
+
+// CHECK-LABEL: define void @byrefattr(ptr byref(i32) %
+llvm.func @byrefattr(%arg0: !llvm.ptr<i32> {llvm.byref = i32}) {
+  llvm.return
+}
+
+// CHECK-LABEL: declare void @byrefattr_decl(ptr byref(i32))
+llvm.func @byrefattr_decl(!llvm.ptr<i32> {llvm.byref = i32})
+
 // CHECK-LABEL: define void @byvalattr(ptr byval(i32) %
 llvm.func @byvalattr(%arg0: !llvm.ptr<i32> {llvm.byval = i32}) {
   llvm.return
 }
 
+// CHECK-LABEL: declare void @byvalattr_decl(ptr byval(i32))
+llvm.func @byvalattr_decl(!llvm.ptr<i32> {llvm.byval = i32})
+
 // CHECK-LABEL: define void @sretattr(ptr sret(i32) %
 llvm.func @sretattr(%arg0: !llvm.ptr<i32> {llvm.sret = i32}) {
   llvm.return
 }
 
+// CHECK-LABEL: declare void @sretattr_decl(ptr sret(i32))
+llvm.func @sretattr_decl(!llvm.ptr<i32> {llvm.sret = i32})
+
 // CHECK-LABEL: define void @nestattr(ptr nest %
 llvm.func @nestattr(%arg0: !llvm.ptr<i32> {llvm.nest}) {
   llvm.return
 }
 
+// CHECK-LABEL: declare void @nestattr_decl(ptr nest)
+llvm.func @nestattr_decl(!llvm.ptr<i32> {llvm.nest})
+
 // CHECK-LABEL: define void @noundefattr(i32 noundef %
 llvm.func @noundefattr(%arg0: i32 {llvm.noundef}) {
   llvm.return
 }
 
+// CHECK-LABEL: declare void @noundefattr_decl(i32 noundef)
+llvm.func @noundefattr_decl(i32 {llvm.noundef})
+
 // CHECK-LABEL: define void @llvm_align(ptr align 4 {{%*.}})
 llvm.func @llvm_align(%arg0: !llvm.ptr<f32> {llvm.align = 4}) {
   llvm.return
 }
 
+// CHECK-LABEL: declare void @llvm_align_decl(ptr align 4)
+llvm.func @llvm_align_decl(!llvm.ptr<f32> {llvm.align = 4})
+
+// CHECK-LABEL: define void @inallocaattr(ptr inalloca(i32) %
+llvm.func @inallocaattr(%arg0: !llvm.ptr<i32> {llvm.inalloca = i32}) {
+  llvm.return
+}
+
+// CHECK-LABEL: declare void @inallocaattr_decl(ptr inalloca(i32))
+llvm.func @inallocaattr_decl(!llvm.ptr<i32> {llvm.inalloca = i32})
+
 // CHECK-LABEL: @llvm_varargs(...)
 llvm.func @llvm_varargs(...)
 
 llvm.func @intpointerconversion(%arg0 : i32) -> i32 {
 // CHECK:      %2 = inttoptr i32 %0 to ptr
 // CHECK-NEXT: %3 = ptrtoint ptr %2 to i32
   %1 = llvm.inttoptr %arg0 : i32 to !llvm.ptr<i32>
   %2 = llvm.ptrtoint %1 : !llvm.ptr<i32> to i32