Use funcop for indirect call (#274)

* Use funcop for indirect call

* Add test

* Add comment

Author: wsmoses

include/polygeist/PolygeistOps.td

@@ -12,6 +12,7 @@
 include "Dialect.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
+include "mlir/IR/SymbolInterfaces.td"
 
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.td"
@@ -111,6 +112,14 @@ def Pointer2MemrefOp : Polygeist_Op<"pointer2memref", [
   }];
 }
 
+def GetFuncOp : Polygeist_Op<"get_func",
+    [NoSideEffect, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+  let summary = "get the pointer pointing to a function";
+  let arguments = (ins FlatSymbolRefAttr:$name);
+  let results = (outs LLVM_AnyPointer : $result);
+  let assemblyFormat = "$name `:` type($result) attr-dict";
+}
+
 def TrivialUseOp : Polygeist_Op<"trivialuse"> {
   let summary = "memref subview operation";
 

lib/polygeist/Ops.cpp

@@ -5005,3 +5005,19 @@ void TypeAlignOp::getCanonicalizationPatterns(RewritePatternSet &results,
       // RankReduction<memref::AllocaOp, scf::ParallelOp>,
       AggressiveAllocaScopeInliner, InductiveVarRemoval>(context);
 }
+
+//===----------------------------------------------------------------------===//
+// GetFuncOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult GetFuncOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
+  // TODO: Verify that the result type is same as the type of the referenced
+  // func.func op.
+  auto global =
+      symbolTable.lookupNearestSymbolFrom<func::FuncOp>(*this, getNameAttr());
+  if (!global)
+    return emitOpError("'")
+           << getName() << "' does not reference a valid global funcOp";
+
+  return success();
+}

lib/polygeist/Passes/ConvertPolygeistToLLVM.cpp

@@ -589,6 +589,29 @@ struct GlobalOpTypeConversion : public OpConversionPattern<LLVM::GlobalOp> {
   }
 };
 
+struct GetFuncOpConversion : public OpConversionPattern<polygeist::GetFuncOp> {
+  explicit GetFuncOpConversion(LLVMTypeConverter &converter)
+      : OpConversionPattern<polygeist::GetFuncOp>(converter,
+                                                  &converter.getContext()) {}
+
+  LogicalResult
+  matchAndRewrite(polygeist::GetFuncOp op,
+                  polygeist::GetFuncOp::Adaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    TypeConverter *converter = getTypeConverter();
+    Type retType = op.getType();
+
+    Type convertedType = converter->convertType(retType);
+    if (!convertedType)
+      return failure();
+
+    rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(op, convertedType,
+                                                   op.getName());
+
+    return success();
+  }
+};
+
 struct ReturnOpTypeConversion : public ConvertOpToLLVMPattern<LLVM::ReturnOp> {
   using ConvertOpToLLVMPattern<LLVM::ReturnOp>::ConvertOpToLLVMPattern;
 
@@ -641,9 +664,8 @@ struct ConvertPolygeistToLLVMPass
 
       converter.addConversion([&](async::TokenType type) { return type; });
 
-      patterns
-          .add<LLVMOpLowering, GlobalOpTypeConversion, ReturnOpTypeConversion>(
-              converter);
+      patterns.add<LLVMOpLowering, GlobalOpTypeConversion,
+                   ReturnOpTypeConversion, GetFuncOpConversion>(converter);
       patterns.add<URLLVMOpLowering>(converter);
 
       // Legality callback for operations that checks whether their operand and

tools/cgeist/Lib/clang-mlir.cc

@@ -3098,10 +3098,19 @@ ValueCategory MLIRScanner::VisitDeclRefExpr(DeclRefExpr *E) {
   auto loc = getMLIRLocation(E->getLocation());
   auto name = E->getDecl()->getName().str();
 
-  if (auto tocall = dyn_cast<FunctionDecl>(E->getDecl()))
-    return ValueCategory(builder.create<LLVM::AddressOfOp>(
-                             loc, Glob.GetOrCreateLLVMFunction(tocall)),
+  if (auto tocall = dyn_cast<FunctionDecl>(E->getDecl())) {
+    auto f = Glob.GetOrCreateMLIRFunction(tocall);
+    auto FT = f.getFunctionType();
+    mlir::Type RT = LLVM::LLVMVoidType::get(f.getContext());
+    if (FT.getNumResults() != 0)
+      RT = FT.getResult(0);
+    LLVM::LLVMFunctionType LFT = LLVM::LLVMFunctionType::get(
+        RT, FT.getInputs(), /*unsupported presentlyFT.isVariadic()*/ false);
+
+    return ValueCategory(builder.create<polygeist::GetFuncOp>(
+                             loc, LLVM::LLVMPointerType::get(LFT), f.getName()),
                          /*isReference*/ true);
+  }
 
   if (auto VD = dyn_cast<VarDecl>(E->getDecl())) {
     if (Captures.find(VD) != Captures.end()) {

tools/cgeist/Test/Verification/indirect.c

@@ -0,0 +1,32 @@
+// RUN: cgeist %s --function=main -S | FileCheck %s
+// RUN: cgeist %s --function=main -S --emit-llvm | FileCheck %s --check-prefix=LLCHECK
+
+int square(int x) {
+  return x*x;
+}
+int meta(int (*f)(int), int x) {
+  return f(x);
+}
+
+int printf(const char*, ...);
+int main() {
+  printf("sq(%d)=%d\n", 3, meta(square, 3));
+  return 0;
+}
+
+// CHECK:   func.func @main() -> i32 attributes
+// CHECK-DAG:     %c3_i32 = arith.constant 3 : i32
+// CHECK-DAG:     %c0_i32 = arith.constant 0 : i32
+// CHECK-NEXT:     %0 = llvm.mlir.addressof @str0 : !llvm.ptr<array<11 x i8>>
+// CHECK-NEXT:     %1 = llvm.getelementptr %0[0, 0] : (!llvm.ptr<array<11 x i8>>) -> !llvm.ptr<i8>
+// CHECK-NEXT:     %2 = polygeist.get_func @square : !llvm.ptr<func<i32 (i32)>>
+// CHECK-NEXT:     %3 = call @meta(%2, %c3_i32) : (!llvm.ptr<func<i32 (i32)>>, i32) -> i32
+// CHECK-NEXT:     %4 = llvm.call @printf(%1, %c3_i32, %3) : (!llvm.ptr<i8>, i32, i32) -> i32
+// CHECK-NEXT:     return %c0_i32 : i32
+// CHECK-NEXT:   }
+
+// LLCHECK: define i32 @main()
+// LLCHECK:   %1 = call i32 @meta(i32 (i32)* @square, i32 3)
+// LLCHECK:   %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str0, i32 0, i32 0), i32 3, i32 %1)
+// LLCHECK:   ret i32 0
+// LLCHECK: }