[mlir][LLVM] Add alignment to LLVMFuncOp

[gysit]

LGTM!

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

let arguments = (ins
     OptionalAttr<DictArrayAttr>:$arg_attrs,
     OptionalAttr<DictArrayAttr>:$res_attrs,
     OptionalAttr<I64Attr>:$function_entry_count,
     OptionalAttr<LLVM_MemoryEffectsAttr>:$memory,
     DefaultValuedAttr<Visibility, "mlir::LLVM::Visibility::Default">:$visibility_,
     OptionalAttr<UnitAttr>:$arm_streaming,
     OptionalAttr<UnitAttr>:$arm_locally_streaming,
     OptionalAttr<StrAttr>:$section,
-    OptionalAttr<UnnamedAddr>:$unnamed_addr
+    OptionalAttr<UnnamedAddr>:$unnamed_addr,
+    OptionalAttr<I64Attr>:$alignment
   );
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "Type":$type,

mlir/lib/Target/LLVMIR/ModuleImport.cpp

LogicalResult ModuleImport::processFunction(llvm::Function *func) {
   if (func->hasSection())
     funcOp.setSection(StringRef(func->getSection()));
 
   funcOp.setVisibility_(convertVisibilityFromLLVM(func->getVisibility()));
 
   if (func->hasComdat())
     funcOp.setComdatAttr(comdatMapping.lookup(func->getComdat()));
 
+  if (llvm::MaybeAlign maybeAlign = func->getAlign())
+    funcOp.setAlignment(maybeAlign->value());
+
   // Handle Function attributes.
   processFunctionAttributes(func, funcOp);
 
   // Convert non-debug metadata by using the dialect interface.
   SmallVector<std::pair<unsigned, llvm::MDNode *>> allMetadata;
   func->getAllMetadata(allMetadata);
   for (auto &[kind, node] : allMetadata) {
     if (!iface.isConvertibleMetadata(kind))

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

if (std::optional<mlir::SymbolRefAttr> comdat = function.getComdat()) {
       llvmFunc->setComdat(comdatMapping.lookup(selectorOp));
     }
 
     if (auto gc = function.getGarbageCollector())
       llvmFunc->setGC(gc->str());
 
     if (auto unnamedAddr = function.getUnnamedAddr())
       llvmFunc->setUnnamedAddr(convertUnnamedAddrToLLVM(*unnamedAddr));
+
+    if (auto alignment = function.getAlignment())
+      llvmFunc->setAlignment(llvm::MaybeAlign(*alignment));
   }
 
   return success();
 }
 
 LogicalResult ModuleTranslation::convertFunctions() {
   // Convert functions.
   for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {

mlir/test/Dialect/LLVMIR/func.mlir

module {
 
   // CHECK-LABEL: llvm.func protected @protected
   llvm.func protected @protected() {
     llvm.return
   }
 
   // CHECK-LABEL: local_unnamed_addr @local_unnamed_addr_func
   llvm.func local_unnamed_addr @local_unnamed_addr_func() {
-      llvm.return
   }
 
+  // CHECK-LABEL: @align_func
+  // CHECK-SAME: attributes {alignment = 2 : i64}
+  llvm.func @align_func() attributes {alignment = 2 : i64} {
+    llvm.return
+  }
+
   // CHECK: llvm.comdat @__llvm_comdat
   llvm.comdat @__llvm_comdat {
     // CHECK: llvm.comdat_selector @any any
     llvm.comdat_selector @any any
   }
   // CHECK: @any() comdat(@__llvm_comdat::@any) attributes
   llvm.func @any() comdat(@__llvm_comdat::@any) attributes { dso_local } {
     llvm.return

mlir/test/Target/LLVMIR/Import/function-attributes.ll

 define void @local_unnamed_addr_func() local_unnamed_addr {
   ret void
 }
 
 // -----
 
 ; CHECK-LABEL: unnamed_addr @unnamed_addr_func
 declare void @unnamed_addr_func() unnamed_addr
+
+// -----
+
+; CHECK-LABEL: @align_func
+; CHECK-SAME: attributes {alignment = 2 : i64}
+define void @align_func() align 2 {
+  ret void
+}
+
+// -----
+
+; CHECK-LABEL: @align_decl
+; CHECK-SAME: attributes {alignment = 64 : i64}
+declare void @align_decl() align 64

mlir/test/Target/LLVMIR/llvmir.mlir

 // -----
 
 // CHECK-LABEL: @unnamed_addr_func
 // CHECK-SAME: unnamed_addr
 llvm.func unnamed_addr @unnamed_addr_func()
 
 // -----
 
+// CHECK-LABEL: @align_func
+// CHECK-SAME: align 2
+llvm.func @align_func() attributes {alignment = 2 : i64} {
+    llvm.return
+}
+
+// -----
+
+// CHECK-LABEL: @align_decl
+// CHECK-SAME: align 64
+llvm.func @align_decl() attributes {alignment = 64 : i64}
+
+// -----
+
 // CHECK-LABEL: @callFreezeOp
 llvm.func @callFreezeOp(%x : i32) {
   // CHECK: freeze i32 %{{[0-9]+}}
   %0 = llvm.freeze %x : i32
   %1 = llvm.mlir.undef : i32
   // CHECK: freeze i32 undef
   %2 = llvm.freeze %1 : i32
   %3 = llvm.mlir.poison : i32