[mlir][LLVM] Add passthrough import support

[Dinistro]

Summary

This commit extends the LLVMIR import to support function attributes by
adding them to the passthrough array attribute.

Depends on D142013

[gysit]

Nice, LGTM modulo comments!

mlir/lib/Target/LLVMIR/ModuleImport.cpp

1431

nit: a->attr or funcAttr?

1432

nit: hande -> handle maybe say "Skip the memory attribute since the funcOp has an explicit memory attribute."

1466

let's use llvm_unreachable here?

mlir/test/Target/LLVMIR/Import/basic.ll

10–11

nit: time to remove the FIXME :)?

[Dinistro]

address review comments

[Dinistro]

change unreachable message

mlir/lib/Target/LLVMIR/ModuleImport.cpp

static void processMemoryEffects(llvm::Function *func, LLVMFuncOp funcOp) {
   auto memAttr = MemoryEffectsAttr::get(funcOp.getContext(), othermem, argMem,
                                         inaccessibleMem);
   // Only set the attr when it does not match the default value.
   if (memAttr.isReadWrite())
     return;
   funcOp.setMemoryAttr(memAttr);
 }
 
+static void processPassthroughAttrs(llvm::Function *func, LLVMFuncOp funcOp) {
+  MLIRContext *context = funcOp.getContext();
+  SmallVector<Attribute> passthroughs;
+  llvm::AttributeSet funcAttrs = func->getAttributes().getAttributes(
+      llvm::AttributeList::AttrIndex::FunctionIndex);
+  for (llvm::Attribute attr : funcAttrs) {
+    // Skip the memory attribute since the LLVMFuncOp has an explicit memory
+    // attribute.
+    if (attr.hasAttribute(llvm::Attribute::Memory))
+      continue;
+
+    // Skip invalid type attributes.
+    if (attr.isTypeAttribute()) {
+      emitWarning(funcOp.getLoc(),
+                  "type attributes on a function are invalid, skipping it");
+      continue;
+    }
+
+    StringRef attrName;
+    if (attr.isStringAttribute())
+      attrName = attr.getKindAsString();
+    else
+      attrName = llvm::Attribute::getNameFromAttrKind(attr.getKindAsEnum());
+    auto keyAttr = StringAttr::get(context, attrName);
+
+    if (attr.isStringAttribute()) {
+      StringRef val = attr.getValueAsString();
+      if (val.empty()) {
+        passthroughs.push_back(keyAttr);
+        continue;
+      }
+      passthroughs.push_back(
+          ArrayAttr::get(context, {keyAttr, StringAttr::get(context, val)}));
+      continue;
+    }
+    if (attr.isIntAttribute()) {
+      auto val = std::to_string(attr.getValueAsInt());
+      passthroughs.push_back(
+          ArrayAttr::get(context, {keyAttr, StringAttr::get(context, val)}));
+      continue;
+    }
+    if (attr.isEnumAttribute()) {
+      passthroughs.push_back(keyAttr);
+      continue;
+    }
+
+    llvm_unreachable("unexpected attribute kind");
+  }
+
+  if (!passthroughs.empty())
+    funcOp.setPassthroughAttr(ArrayAttr::get(context, passthroughs));
+}
+
 void ModuleImport::processFunctionAttributes(llvm::Function *func,
                                              LLVMFuncOp funcOp) {
   processMemoryEffects(func, funcOp);
+  processPassthroughAttrs(func, funcOp);
 }
 
 LogicalResult ModuleImport::processFunction(llvm::Function *func) {
   clearBlockAndValueMapping();
 
   auto functionType =
       convertType(func->getFunctionType()).dyn_cast<LLVMFunctionType>();
   if (func->isIntrinsic() &&

mlir/test/Target/LLVMIR/Import/basic.ll

 ; RUN: mlir-translate -opaque-pointers=0 -import-llvm %s | FileCheck %s
 ; RUN: mlir-translate -opaque-pointers=0 -import-llvm -mlir-print-debuginfo %s | FileCheck %s --check-prefix=CHECK-DBG
 
 ; CHECK-DBG: #[[MODULELOC:.+]] = loc({{.*}}basic.ll{{.*}}:0:0)
 
 @global = external global double, align 8
 
 ; CHECK: llvm.func @fe(i32) -> f32
 declare float @fe(i32)
 
-; FIXME: function attributes.
-; CHECK-LABEL: llvm.func internal @f1(%arg0: i64) -> i32 attributes {dso_local} {
-; CHECK-DBG: llvm.func internal @f1(%arg0: i64 loc({{.*}}basic.ll{{.*}}:0:0)) -> i32 attributes {dso_local} {
+; CHECK-LABEL: llvm.func internal @f1(%arg0: i64) -> i32 attributes {dso_local, passthrough = ["norecurse"]} {
+; CHECK-DBG: llvm.func internal @f1(%arg0: i64 loc({{.*}}basic.ll{{.*}}:0:0)) -> i32 attributes {dso_local, passthrough = ["norecurse"]} {
 ; CHECK: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
 ; CHECK: %[[c1:[0-9]+]] = llvm.mlir.constant(true) : i1
 ; CHECK: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : i32
 ; CHECK: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : i32
 define internal dso_local i32 @f1(i64 %a) norecurse {
 entry:
 ; CHECK: %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
   %aa = inttoptr i64 %a to i64*

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

-; RUN: mlir-translate -import-llvm -split-input-file %s | FileCheck %s
+; RUN: mlir-translate -import-llvm -split-input-file %s --verify-diagnostics | FileCheck %s
 
 ; CHECK: llvm.func internal @func_internal
 define internal void @func_internal() {
   ret void
 }
 
 ; CHECK: llvm.func internal spir_funccc @spir_func_internal()
 define internal spir_func void @spir_func_internal() {

 ; // -----
 
 ; CHECK-LABEL: @func_memory
 ; CHECK-SAME:  attributes {memory = #llvm.memory_effects<other = readwrite, argMem = none, inaccessibleMem = readwrite>}
 ; CHECK:   llvm.return
 define void @func_memory() memory(readwrite, argmem: none) {
   ret void
 }
+
+; // -----
+
+; CHECK-LABEL: @passthrough_combined
+; CHECK-SAME: attributes {passthrough = [
+; CHECK-DAG: ["alignstack", "16"]
+; CHECK-DAG: "noinline"
+; CHECK-DAG: "probe-stack"
+; CHECK-DAG: ["alloc-family", "malloc"]
+; CHECK:   llvm.return
+define void @passthrough_combined() alignstack(16) noinline "probe-stack" "alloc-family"="malloc" {
+  ret void
+}
+
+// -----
+
+; CHECK-LABEL: @passthrough_string_only
+; CHECK-SAME: attributes {passthrough = ["no-enum-attr"]}
+; CHECK:   llvm.return
+define void @passthrough_string_only() "no-enum-attr" {
+  ret void
+}