fixup! [mlir][LLVMIR] Add IFuncOp to LLVM dialect

Author: Jezurko

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

@@ -1629,7 +1629,7 @@ def LLVM_IFuncOp : LLVM_Op<"mlir.ifunc",
     Examples:
 
     ```mlir
-    // IFuncs have @-identifier and use a resolver function.
+    // IFuncs resolve a symbol at runtime using a resovler function.
     llvm.mlir.ifunc external @foo: !llvm.func<f32 (i64)>, !llvm.ptr @resolver
 
     llvm.func @foo_1(i64) -> f32

mlir/include/mlir/Target/LLVMIR/ModuleImport.h

@@ -323,7 +323,7 @@ class ModuleImport {
   /// Converts an LLVM global alias variable into an MLIR LLVM dialect alias
   /// operation if a conversion exists. Otherwise, returns failure.
   LogicalResult convertAlias(llvm::GlobalAlias *alias);
-  // Converts an LLVM global ifunc into an MLIR LLVM dialect ifunc operation
+  // Converts an LLVM global ifunc into an MLIR LLVM dialect ifunc operation.
   LogicalResult convertIFunc(llvm::GlobalIFunc *ifunc);
   /// Returns personality of `func` as a FlatSymbolRefAttr.
   FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *func);

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

@@ -2709,14 +2709,24 @@ void IFuncOp::build(OpBuilder &builder, OperationState &result, StringRef name,
 LogicalResult IFuncOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   Operation *symbol =
       symbolTable.lookupSymbolIn(parentLLVMModule(*this), getResolverAttr());
+  // This matches LLVM IR verification logic, see llvm/lib/IR/Verifier.cpp
   auto resolver = dyn_cast<LLVMFuncOp>(symbol);
-  if (!resolver) {
-    // FIXME: Strip aliases to find the called function
-    if (isa<AliasOp>(symbol))
+  auto alias = dyn_cast<AliasOp>(symbol);
+  while (alias) {
+    Block &initBlock = alias.getInitializerBlock();
+    auto returnOp = cast<ReturnOp>(initBlock.getTerminator());
+    auto addrOp = dyn_cast<AddressOfOp>(returnOp.getArg().getDefiningOp());
+    // FIXME: This is a best effort solution. The AliasOp body might be more
+    // complex and in that case we bail out with success. To completely match
+    // the LLVM IR logic it would be necessary to implement proper alias and
+    // cast stripping.
+    if (!addrOp)
       return success();
-    return emitOpError("must have a function resolver");
+    resolver = addrOp.getFunction(symbolTable);
+    alias = addrOp.getAlias(symbolTable);
   }
-  // This matches LLVM IR verification logic, see from llvm/lib/IR/Verifier.cpp
+  if (!resolver)
+    return emitOpError("must have a function resolver");
   Linkage linkage = resolver.getLinkage();
   if (resolver.isExternal() || linkage == Linkage::AvailableExternally)
     return emitOpError("resolver must be a definition");

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

@@ -1877,11 +1877,11 @@ LogicalResult ModuleTranslation::convertIFuncs() {
         convertLinkageToLLVM(op.getLinkage());
     llvm::Constant *resolver;
     if (auto *resolverFn = lookupFunction(op.getResolver())) {
-      resolver = dyn_cast<llvm::Constant>(resolverFn);
+      resolver = cast<llvm::Constant>(resolverFn);
     } else {
-      Operation *aliasTrg = symbolTable().lookupSymbolIn(parentLLVMModule(op),
-                                                         op.getResolverAttr());
-      resolver = cast<llvm::Constant>(lookupAlias(aliasTrg));
+      Operation *aliasOp = symbolTable().lookupSymbolIn(parentLLVMModule(op),
+                                                        op.getResolverAttr());
+      resolver = cast<llvm::Constant>(lookupAlias(aliasOp));
     }
 
     auto *ifunc =

mlir/test/Dialect/LLVMIR/ifunc.mlir

@@ -31,7 +31,6 @@ llvm.func @resolver() -> !llvm.ptr {
 // -----
 
 // CHECK: llvm.mlir.ifunc weak @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver
-
 llvm.mlir.ifunc weak @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver
 llvm.func @resolver() -> !llvm.ptr {
   %0 = llvm.mlir.constant(333 : i64) : i64

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

@@ -4,32 +4,15 @@
 @foo = dso_local ifunc void (ptr, i32), ptr @resolve_foo
 
 define dso_local void @call_foo(ptr noundef %0, i32 noundef %1) {
-  %3 = alloca ptr, align 8
-  %4 = alloca i32, align 4
-  store ptr %0, ptr %3, align 8
-  store i32 %1, ptr %4, align 4
-  %5 = load ptr, ptr %3, align 8
-  %6 = load i32, ptr %4, align 4
 ; CHECK: llvm.call @foo
-  call void @foo(ptr noundef %5, i32 noundef %6)
+  call void @foo(ptr noundef %0, i32 noundef %1)
   ret void
 }
 
-define dso_local void @call_indirect_foo(ptr noundef %0, i32 noundef %1) {
-  %3 = alloca ptr, align 8
-  %4 = alloca i32, align 4
-  %5 = alloca ptr, align 8
-; CHECK: [[CALLEE:%[0-9]+]] = llvm.mlir.addressof @foo
-; CHECK: llvm.store [[CALLEE]], [[STORED:%[0-9]+]]
-; CHECK: [[LOADED_CALLEE:%[0-9]+]] = llvm.load [[STORED]]
-  store ptr %0, ptr %3, align 8
-  store i32 %1, ptr %4, align 4
-  store ptr @foo, ptr %5, align 8
-  %6 = load ptr, ptr %5, align 8
-  %7 = load ptr, ptr %3, align 8
-  %8 = load i32, ptr %4, align 4
-  call void %6(ptr noundef %7, i32 noundef %8)
-  ret void
+define dso_local ptr @foo_fptr() {
+; CHECK: [[FPTR:%[0-9]+]] = llvm.mlir.addressof @foo
+; CHECK: llvm.return [[FPTR]]
+  ret ptr @foo
 }
 
 define internal ptr @resolve_foo() {

mlir/test/Target/LLVMIR/ifunc.mlir

@@ -3,34 +3,14 @@
 // CHECK: @foo = dso_local ifunc void (ptr, i32), ptr @resolve_foo
 llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo {dso_local}
 llvm.func @call_foo(%arg0: !llvm.ptr {llvm.noundef}, %arg1: i32 {llvm.noundef}) attributes {dso_local} {
-  %0 = llvm.mlir.constant(1 : i32) : i32
-  %1 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
-  %2 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
-  llvm.store %arg0, %1 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
-  llvm.store %arg1, %2 {alignment = 4 : i64} : i32, !llvm.ptr
-  %3 = llvm.load %1 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
-  %4 = llvm.load %2 {alignment = 4 : i64} : !llvm.ptr -> i32
 // CHECK: call void @foo
-  llvm.call @foo(%3, %4) : (!llvm.ptr {llvm.noundef}, i32 {llvm.noundef}) -> ()
+  llvm.call @foo(%arg0, %arg1) : (!llvm.ptr {llvm.noundef}, i32 {llvm.noundef}) -> ()
   llvm.return
 }
-llvm.func @call_indirect_foo(%arg0: !llvm.ptr {llvm.noundef}, %arg1: i32 {llvm.noundef}) attributes {dso_local} {
-  %0 = llvm.mlir.constant(1 : i32) : i32
+llvm.func @foo_fptr() -> !llvm.ptr attributes {dso_local} {
   %1 = llvm.mlir.addressof @foo : !llvm.ptr
-  %2 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
-  %3 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
-  %4 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
-  llvm.store %arg0, %2 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
-  llvm.store %arg1, %3 {alignment = 4 : i64} : i32, !llvm.ptr
-// CHECK: store ptr @foo, ptr [[STORED:%[0-9]+]]
-  llvm.store %1, %4 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
-// CHECK: [[LOADED:%[0-9]+]] = load ptr, ptr [[STORED]]
-  %5 = llvm.load %4 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
-  %6 = llvm.load %2 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
-  %7 = llvm.load %3 {alignment = 4 : i64} : !llvm.ptr -> i32
-// CHECK: call void [[LOADED]]
-  llvm.call %5(%6, %7) : !llvm.ptr, (!llvm.ptr {llvm.noundef}, i32 {llvm.noundef}) -> ()
-  llvm.return
+// CHECK: ret ptr @foo
+  llvm.return %1 : !llvm.ptr
 }
 llvm.func internal @resolve_foo() -> !llvm.ptr attributes {dso_local} {
   %0 = llvm.mlir.addressof @foo_1 : !llvm.ptr
@@ -62,7 +42,6 @@ llvm.func @resolver() -> !llvm.ptr {
 // -----
 
 // CHECK: @ifunc = linkonce_odr hidden ifunc
-
 llvm.mlir.ifunc linkonce_odr hidden @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
 llvm.func @resolver() -> !llvm.ptr {
   %0 = llvm.mlir.constant(333 : i64) : i64
@@ -73,7 +52,6 @@ llvm.func @resolver() -> !llvm.ptr {
 // -----
 
 // CHECK: @ifunc = private ifunc
-
 llvm.mlir.ifunc private @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
 llvm.func @resolver() -> !llvm.ptr {
   %0 = llvm.mlir.constant(333 : i64) : i64
@@ -84,7 +62,6 @@ llvm.func @resolver() -> !llvm.ptr {
 // -----
 
 // CHECK: @ifunc = weak ifunc
-
 llvm.mlir.ifunc weak @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver
 llvm.func @resolver() -> !llvm.ptr {
   %0 = llvm.mlir.constant(333 : i64) : i64