[flang][CodeGen] Transform `fir.call` to `llvm.call`

[awarzynski]

Summary

This patch extends the FIRToLLVMLowering pass in Flang by adding a
hook to transform fir.call to llvm.call.

This is part of the upstreaming effort from the fir-dev branch in [1].

[1] https://github.com/flang-compiler/f18-llvm-project

Patch originally written by:
Co-authored-by: Eric Schweitz <[e-mail]>
Co-authored-by: V Donaldson <[e-mail]>

[clementval]

LGTM. We can add tests with more complex arguments as we add their conversion in.

[kiranchandramohan]

LGTM.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

82

micro NIT: fir.cal -> fir.call :)

flang/lib/Optimizer/CodeGen/CodeGen.cpp

matchAndRewrite(fir::AddrOfOp addr, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(addr.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(
         addr, ty, addr.symbol().getRootReference().getValue());
     return success();
   }
 };
 
+// `fir.call` -> `llvm.call`
+struct CallOpConversion : public FIROpConversion<fir::CallOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::CallOp call, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    SmallVector<mlir::Type> resultTys;
+    for (auto r : call.getResults())
+      resultTys.push_back(convertType(r.getType()));
+    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
+        call, resultTys, adaptor.getOperands(), call->getAttrs());
+    return success();
+  }
+};
+
 /// Lower `fir.has_value` operation to `llvm.return` operation.
 struct HasValueOpConversion : public FIROpConversion<fir::HasValueOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::HasValueOp op, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, adaptor.getOperands());

 public:
   mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::OwningRewritePatternList pattern(context);
     pattern.insert<
-        AddrOfOpConversion, ExtractValueOpConversion, HasValueOpConversion,
-        GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
-        SelectOpConversion, SelectRankOpConversion, UndefOpConversion,
-        UnreachableOpConversion, ZeroOpConversion>(typeConverter);
+        AddrOfOpConversion, CallOpConversion, ExtractValueOpConversion,
+        HasValueOpConversion, GlobalOpConversion, InsertOnRangeOpConversion,
+        InsertValueOpConversion, SelectOpConversion, SelectRankOpConversion,
+        UndefOpConversion, UnreachableOpConversion, ZeroOpConversion>(
+        typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
     mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
                                                             pattern);
     mlir::ConversionTarget target{*context};
     target.addLegalDialect<mlir::LLVM::LLVMDialect>();
 
     // required NOPs for applying a full conversion
     target.addLegalOp<mlir::ModuleOp>();

flang/test/Fir/convert-to-llvm.fir

func @insert_tuple(%a : tuple<i32, f32>) {
   %1 = fir.insert_value %a, %f, [1 : index] : (tuple<i32, f32>, f32) -> tuple<i32, f32>
   return
 }
 
 // CHECK-LABEL: func @insert_tuple(
 // CHECK-SAME:                     %[[TUPLE:.*]]: !llvm.struct<(i32, f32)>
 // CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[TUPLE]][1 : index] : !llvm.struct<(i32, f32)>
 // CHECK:         llvm.return
+
+// -----
+// Test `fir.call` -> `llvm.call` conversion for functions that take no arguments
+// and return nothing
+
+func @dummy_basic() {
+  return
+}
+
+func @test_call_basic() {
+  fir.call @dummy_basic() : () -> ()
+  return
+}
+
+// CHECK-LABEL: func @test_call_basic() {
+// CHECK-NEXT:  llvm.call @dummy_basic() : () -> ()
+// CHECK-NEXT:  return
+// CHECK-NEXT: }
+
+// Test `fir.call` -> `llvm.call` conversion for functions that take one
+// argument and return nothing
+
+func @dummy_with_arg(%arg0 : i32) {
+  return
+}
+
+func @test_call_with_arg(%arg0 : i32) {
+  fir.call @dummy_with_arg(%arg0) : (i32) -> ()
+  return
+}
+
+// CHECK-LABEL:  llvm.func @test_call_with_arg(%arg0: i32) {
+// CHECK-NEXT:    llvm.call @dummy_with_arg(%arg0) : (i32) -> ()
+// CHECK-NEXT:    llvm.return
+// CHECK-NEXT:  }
+
+// Test `fir.call` -> `llvm.call` conversion for functions that take no
+// arguments, but return a value
+
+func @dummy_return_val() -> i32 {
+  %1 = arith.constant 123 : i32
+  return %1 : i32
+}
+
+func @test_call_return_val() -> i32 {
+  %1 = fir.call @dummy_return_val() : () -> (i32)
+  return %1 : i32
+}
+
+// CHECK-LABEL:  llvm.func @test_call_return_val() -> i32 {
+// CHECK-NEXT:    %0 = llvm.call @dummy_return_val() : () -> i32
+// CHECK-NEXT:    llvm.return %0 : i32
+// CHECK-NEXT:  }