[flang] Fix function result rewrite for CPTR type

[peixin]

Summary

Not all derived type can be taken as abstract result. The CPTR type
should be treated as return by value so to interoperable with C
functions. Fix the function result rewrite for CPTR type, but it
should be generalized for all derived types. The ABI of
interoperability with C for derived type is architecture dependent,
which should be supported later.

[PeteSteinfeld]

Thanks so much for working on this. Aside from a few comments on function names and grammar in comments, all builds and tests correctly and looks good to me.

I've also verified that this fixes the test case in issue #58772.

@jeanPerier, can you also please take a look at this patch?

flang/lib/Optimizer/Transforms/AbstractResult.cpp

61–62

It looks like the function getNewFuncResultType is specific to functions that return CPTR types. If so, I recommend that this be reflected in the name -- perhaps getCptrFuncResultType?

Also, I would reword the comment as follows:

/// This is for function result types that are of type C_PTR from ISO_C_BINDING.  Follow the
/// ABI for interoperability with C.

109

"derived type" should read "derived types".

192

"derived type" should read "derived types".

325

"derived type" should read "derived types".

[peixin]

Will support AddrOfOp rewrite, too. It is for procedure passed as argument.

[peixin]

Address the comments and add support for AddrOp rewrite.

[jeanPerier]

flang/lib/Optimizer/Transforms/AbstractResult.cpp

149

Shouldn't this be callOp.getOperands().begin() +1 to skip the function address that was already added above ?
If so, I think the !isResultBuiltinCPtr could just guard newOperands.push_back(arg);.

flang/test/Fir/abstract-results.fir

90

Why not using fir.ref<None> so that it is sure the ABI matches what is done for a void* return type in C ?

[peixin]

flang/lib/Optimizer/Transforms/AbstractResult.cpp

149

Did you comment this when you read the last update? I think this has been updated.

flang/test/Fir/abstract-results.fir

90

The test case happened to return a C pointer. It does seem to be more reasonable to return fir.ref<None> for a c_ptr. However, for general purpose of ABI of returning a derived type with only one component with the type i64, the ABI for the derived type returned is i64. Finally, there will be no isa_builtin_cptr_type check for c_ptr. Instead, it will be replaced with checking the derived type. At that time, we need to i64 for c_ptr return value.

[PeteSteinfeld]

Thanks for the quick fix!

All builds and tests correctly and looks good to me. I've also verified that this fixes issue #58849.

Please wait for @jeanPerier to approve before merging.

[jeanPerier]

flang/lib/Optimizer/Transforms/AbstractResult.cpp

149

Yes, looks good now.

flang/test/Fir/abstract-results.fir

90

Let's discuss this outside of this change. I feel C_PTR is special enough so that we should not treat it as a struct {i64} in function interface. I just feel using fir.ref<None> will ensure it is OK regardless of the ABI (it is likely i64 works with most, but it would just be simpler to use fir.ref<None> than to verify this assumption for every ABI).

Then, I am not entirely clear where you are going with the next change extending this to single component derived types. Is this only in the BIND(C) context or for all functions ? For BIND(C), I agree we may have to go down that rabbit hole, and it won't be fun to replicate the C ABI generated by clang for structs, that I guess is likely target dependent.
Outside of the BIND(C) context, it is not clear to me what would be the reason for doing this (ifort and nvfortran are not doing this I believe). I would stay away from it (the only issue I see is that in the abstract result rewrite pass you do not have a way to tell if a function type is bind(C) or not, and with indirect calls, there may not be a funcOp declaration to tell that).

flang/lib/Optimizer/Dialect/FIRType.cpp

return tuple && tuple.size() == 2 &&
           (acceptRawFunc && tuple.getType(0).isa<mlir::FunctionType>())) &&
          fir::isa_integer(tuple.getType(1));
 }
 
 bool fir::hasAbstractResult(mlir::FunctionType ty) {
   if (ty.getNumResults() == 0)
     return false;
   auto resultType = ty.getResult(0);
-  // FIXME: The interoperable derived type needs more investigations and tests.
-  // The derived type without BIND attribute may also not be abstract result.
-  if (fir::isa_builtin_cptr_type(resultType))
-    return false;
   return resultType.isa<fir::SequenceType, fir::BoxType, fir::RecordType>();
 }
 
 /// Convert llvm::Type::TypeID to mlir::Type. \p kind is provided for error
 /// messages only.
 mlir::Type fir::fromRealTypeID(mlir::MLIRContext *context,
                                llvm::Type::TypeID typeID, fir::KindTy kind) {
   switch (typeID) {

flang/lib/Optimizer/Transforms/AbstractResult.cpp

 //===- AbstractResult.cpp - Conversion of Abstract Function Result --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/TypeSwitch.h"
 
static mlir::FunctionType getNewFunctionType(mlir::FunctionType funcTy,
   auto resultType = funcTy.getResult(0);
   auto argTy = getResultArgumentType(resultType, shouldBoxResult);
   llvm::SmallVector<mlir::Type> newInputTypes = {argTy};
   newInputTypes.append(funcTy.getInputs().begin(), funcTy.getInputs().end());
   return mlir::FunctionType::get(funcTy.getContext(), newInputTypes,
                                  /*resultTypes=*/{});
 }
 
+/// This is for function result types that are of type C_PTR from ISO_C_BINDING.
+/// Follow the ABI for interoperability with C.
+static mlir::FunctionType getCPtrFunctionType(mlir::FunctionType funcTy) {
+  auto resultType = funcTy.getResult(0);
+  assert(fir::isa_builtin_cptr_type(resultType));
+  llvm::SmallVector<mlir::Type> outputTypes;
+  auto recTy = resultType.dyn_cast<fir::RecordType>();
+  outputTypes.emplace_back(recTy.getTypeList()[0].second);
+  return mlir::FunctionType::get(funcTy.getContext(), funcTy.getInputs(),
+                                 outputTypes);
+}
+
 static bool mustEmboxResult(mlir::Type resultType, bool shouldBoxResult) {
   return resultType.isa<fir::SequenceType, fir::RecordType>() &&
          shouldBoxResult;
 }
 
 class CallOpConversion : public mlir::OpRewritePattern<fir::CallOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
matchAndRewrite(fir::CallOp callOp,
     auto buffer = saveResult.getMemref();
     mlir::Value arg = buffer;
     if (mustEmboxResult(result.getType(), shouldBoxResult))
       arg = rewriter.create<fir::EmboxOp>(
           loc, argType, buffer, saveResult.getShape(), /*slice*/ mlir::Value{},
           saveResult.getTypeparams());
 
     llvm::SmallVector<mlir::Type> newResultTypes;
+    // TODO: This should be generalized for derived types, and it is
+    // architecture and OS dependent.
+    bool isResultBuiltinCPtr = fir::isa_builtin_cptr_type(result.getType());
+    fir::CallOp newCallOp;
+    if (isResultBuiltinCPtr) {
+      auto recTy = result.getType().dyn_cast<fir::RecordType>();
+      newResultTypes.emplace_back(recTy.getTypeList()[0].second);
+    }
     if (callOp.getCallee()) {
-      llvm::SmallVector<mlir::Value> newOperands = {arg};
+      llvm::SmallVector<mlir::Value> newOperands;
+      if (!isResultBuiltinCPtr)
+        newOperands.emplace_back(arg);
       newOperands.append(callOp.getOperands().begin(),
                          callOp.getOperands().end());
-      rewriter.create<fir::CallOp>(loc, *callOp.getCallee(), newResultTypes,
-                                   newOperands);
+      newCallOp = rewriter.create<fir::CallOp>(loc, *callOp.getCallee(),
+                                               newResultTypes, newOperands);
     } else {
       // Indirect calls.
-      llvm::SmallVector<mlir::Type> newInputTypes = {argType};
+      llvm::SmallVector<mlir::Type> newInputTypes;
+      if (!isResultBuiltinCPtr)
+        newInputTypes.emplace_back(argType);
       for (auto operand : callOp.getOperands().drop_front())
         newInputTypes.push_back(operand.getType());
-      auto funTy = mlir::FunctionType::get(callOp.getContext(), newInputTypes,
-                                           newResultTypes);
+      auto newFuncTy = mlir::FunctionType::get(callOp.getContext(),
+                                               newInputTypes, newResultTypes);
 
       llvm::SmallVector<mlir::Value> newOperands;
-      newOperands.push_back(
-          rewriter.create<fir::ConvertOp>(loc, funTy, callOp.getOperand(0)));
+      newOperands.push_back(rewriter.create<fir::ConvertOp>(
+          loc, newFuncTy, callOp.getOperand(0)));
+      if (!isResultBuiltinCPtr)
         newOperands.push_back(arg);
       newOperands.append(callOp.getOperands().begin() + 1,
                          callOp.getOperands().end());
-      rewriter.create<fir::CallOp>(loc, mlir::SymbolRefAttr{}, newResultTypes,
-                                   newOperands);
+      newCallOp = rewriter.create<fir::CallOp>(loc, mlir::SymbolRefAttr{},
+                                               newResultTypes, newOperands);
+    }
+    if (isResultBuiltinCPtr) {
+      mlir::Value save = saveResult.getMemref();
+      auto module = callOp->getParentOfType<mlir::ModuleOp>();
+      fir::KindMapping kindMap = fir::getKindMapping(module);
+      FirOpBuilder builder(rewriter, kindMap);
+      mlir::Value saveAddr = fir::factory::genCPtrOrCFunptrAddr(
+          builder, loc, save, result.getType());
+      rewriter.create<fir::StoreOp>(loc, newCallOp->getResult(0), saveAddr);
     }
     callOp->dropAllReferences();
     rewriter.eraseOp(callOp);
     return mlir::success();
   }
 
 private:
   bool shouldBoxResult;

 class ReturnOpConversion : public mlir::OpRewritePattern<mlir::func::ReturnOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
   ReturnOpConversion(mlir::MLIRContext *context, mlir::Value newArg)
       : OpRewritePattern(context), newArg{newArg} {}
   mlir::LogicalResult
   matchAndRewrite(mlir::func::ReturnOp ret,
                   mlir::PatternRewriter &rewriter) const override {
+    auto loc = ret.getLoc();
     rewriter.setInsertionPoint(ret);
     auto returnedValue = ret.getOperand(0);
     bool replacedStorage = false;
     if (auto *op = returnedValue.getDefiningOp())
       if (auto load = mlir::dyn_cast<fir::LoadOp>(op)) {
         auto resultStorage = load.getMemref();
+        // TODO: This should be generalized for derived types, and it is
+        // architecture and OS dependent.
+        if (fir::isa_builtin_cptr_type(returnedValue.getType())) {
+          rewriter.eraseOp(load);
+          auto module = ret->getParentOfType<mlir::ModuleOp>();
+          fir::KindMapping kindMap = fir::getKindMapping(module);
+          FirOpBuilder builder(rewriter, kindMap);
+          mlir::Value retAddr = fir::factory::genCPtrOrCFunptrAddr(
+              builder, loc, resultStorage, returnedValue.getType());
+          mlir::Value retValue = rewriter.create<fir::LoadOp>(
+              loc, fir::unwrapRefType(retAddr.getType()), retAddr);
+          rewriter.replaceOpWithNewOp<mlir::func::ReturnOp>(
+              ret, mlir::ValueRange{retValue});
+          return mlir::success();
+        }
         load.getMemref().replaceAllUsesWith(newArg);
         replacedStorage = true;
         if (auto *alloc = resultStorage.getDefiningOp())
           if (alloc->use_empty())
             rewriter.eraseOp(alloc);
       }
     // The result storage may have been optimized out by a memory to
     // register pass, this is possible for fir.box results, or fir.record
     // with no length parameters. Simply store the result in the result storage.
     // at the return point.
     if (!replacedStorage)
-      rewriter.create<fir::StoreOp>(ret.getLoc(), returnedValue, newArg);
+      rewriter.create<fir::StoreOp>(loc, returnedValue, newArg);
     rewriter.replaceOpWithNewOp<mlir::func::ReturnOp>(ret);
     return mlir::success();
   }
 
 private:
   mlir::Value newArg;
 };
 
 class AddrOfOpConversion : public mlir::OpRewritePattern<fir::AddrOfOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
   AddrOfOpConversion(mlir::MLIRContext *context, bool shouldBoxResult)
       : OpRewritePattern(context), shouldBoxResult{shouldBoxResult} {}
   mlir::LogicalResult
   matchAndRewrite(fir::AddrOfOp addrOf,
                   mlir::PatternRewriter &rewriter) const override {
     auto oldFuncTy = addrOf.getType().cast<mlir::FunctionType>();
-    auto newFuncTy = getNewFunctionType(oldFuncTy, shouldBoxResult);
+    mlir::FunctionType newFuncTy;
+    // TODO: This should be generalized for derived types, and it is
+    // architecture and OS dependent.
+    if (oldFuncTy.getNumResults() != 0 &&
+        fir::isa_builtin_cptr_type(oldFuncTy.getResult(0)))
+      newFuncTy = getCPtrFunctionType(oldFuncTy);
+    else
+      newFuncTy = getNewFunctionType(oldFuncTy, shouldBoxResult);
     auto newAddrOf = rewriter.create<fir::AddrOfOp>(addrOf.getLoc(), newFuncTy,
                                                     addrOf.getSymbol());
     // Rather than converting all op a function pointer might transit through
     // (e.g calls, stores, loads, converts...), cast new type to the abstract
     // type. A conversion will be added when calling indirect calls of abstract
     // types.
     rewriter.replaceOpWithNewOp<fir::ConvertOp>(addrOf, oldFuncTy, newAddrOf);
     return mlir::success();
public:
   void runOnSpecificOperation(mlir::func::FuncOp func, bool shouldBoxResult,
                               mlir::RewritePatternSet &patterns,
                               mlir::ConversionTarget &target) {
     auto loc = func.getLoc();
     auto *context = &getContext();
     // Convert function type itself if it has an abstract result.
     auto funcTy = func.getFunctionType().cast<mlir::FunctionType>();
     if (hasAbstractResult(funcTy)) {
+      // TODO: This should be generalized for derived types, and it is
+      // architecture and OS dependent.
+      if (fir::isa_builtin_cptr_type(funcTy.getResult(0))) {
+        func.setType(getCPtrFunctionType(funcTy));
+        patterns.insert<ReturnOpConversion>(context, mlir::Value{});
+        target.addDynamicallyLegalOp<mlir::func::ReturnOp>(
+            [](mlir::func::ReturnOp ret) {
+              mlir::Type retTy = ret.getOperand(0).getType();
+              return !fir::isa_builtin_cptr_type(retTy);
+            });
+        return;
+      }
       func.setType(getNewFunctionType(funcTy, shouldBoxResult));
       if (!func.empty()) {
         // Insert new argument.
         mlir::OpBuilder rewriter(context);
         auto resultType = funcTy.getResult(0);
         auto argTy = getResultArgumentType(resultType, shouldBoxResult);
         mlir::Value newArg = func.front().insertArgument(0u, argTy, loc);
         if (mustEmboxResult(resultType, shouldBoxResult)) {

flang/test/Fir/abstract-results.fir

func.func @boxfunc_callee() -> !fir.box<!fir.heap<f64>> {
   // FUNC-REF: fir.store %[[box]] to %[[buffer]] : !fir.ref<!fir.box<!fir.heap<f64>>>
   // FUNC-REF: return
 
   // FUNC-BOX: %[[box:.*]] = fir.embox %{{.*}} : (!fir.heap<f64>) -> !fir.box<!fir.heap<f64>>
   // FUNC-BOX: fir.store %[[box]] to %[[buffer]] : !fir.ref<!fir.box<!fir.heap<f64>>>
   // FUNC-BOX: return
 }
 
+// FUNC-REF-LABEL: func @retcptr() -> i64
+// FUNC-BOX-LABEL: func @retcptr() -> i64
+func.func @retcptr() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {
+  %0 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = "rec", uniq_name = "_QFrecErec"}
+  %1 = fir.load %0 : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>
+  return %1 : !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+
+  // FUNC-REF: %[[ALLOC:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = "rec", uniq_name = "_QFrecErec"}
+  // FUNC-REF: %[[FIELD:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  // FUNC-REF: %[[ADDR:.*]] = fir.coordinate_of %[[ALLOC]], %[[FIELD]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+  // FUNC-REF: %[[VAL:.*]] = fir.load %[[ADDR]] : !fir.ref<i64>
+  // FUNC-REF: return %[[VAL]] : i64
+  // FUNC-BOX: %[[ALLOC:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = "rec", uniq_name = "_QFrecErec"}
+  // FUNC-BOX: %[[FIELD:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  // FUNC-BOX: %[[ADDR:.*]] = fir.coordinate_of %[[ALLOC]], %[[FIELD]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+  // FUNC-BOX: %[[VAL:.*]] = fir.load %[[ADDR]] : !fir.ref<i64>
+  // FUNC-BOX: return %[[VAL]] : i64
+}
+
+
 // ------------------------ Test caller rewrite --------------------------------
 
 // FUNC-REF-LABEL: func @call_arrayfunc() {
 // FUNC-BOX-LABEL: func @call_arrayfunc() {
 func.func @call_arrayfunc() {
   %c100 = arith.constant 100 : index
   %buffer = fir.alloca !fir.array<?xf32>, %c100
   %shape = fir.shape %c100 : (index) -> !fir.shape<1>
func.func @call_chararrayfunc() {
   // FUNC-BOX: %[[c50:.*]] = arith.constant 50 : index
   // FUNC-BOX: %[[buffer:.*]] = fir.alloca !fir.array<?x!fir.char<1,?>>(%[[c100]] : index), %[[c50]]
   // FUNC-BOX: %[[shape:.*]] = fir.shape %[[c100]] : (index) -> !fir.shape<1>
   // FUNC-BOX: %[[box:.*]] = fir.embox %[[buffer]](%[[shape]]) typeparams %[[c50]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
   // FUNC-BOX: fir.call @chararrayfunc(%[[box]], %[[c100]], %[[c50]]) : (!fir.box<!fir.array<?x!fir.char<1,?>>>, index, index) -> ()
   // FUNC-BOX-NOT: fir.save_result
 }
 
-func.func private @rettcptr() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> attributes {fir.bindc_name = "rettcptr"}
-
-// FUNC-REF-LABEL: func @_QPtest_return_cptr() {
-// FUNC-BOX-LABEL: func @_QPtest_return_cptr() {
+// FUNC-REF-LABEL: func @_QPtest_return_cptr
+// FUNC-BOX-LABEL: func @_QPtest_return_cptr
 func.func @_QPtest_return_cptr() {
-  // FUNC-REF: [[VAL:.*]] = fir.call @rettcptr() : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
-  // FUNC-BOX: [[VAL:.*]] = fir.call @rettcptr() : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
-  %1 = fir.call @rettcptr() : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  %0 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = ".result"}
+  %1 = fir.call @retcptr() : () -> i64
+  %2 = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  %3 = fir.coordinate_of %0, %2 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+  fir.store %1 to %3 : !fir.ref<i64>
   return
+
+  // FUNC-REF: %[[ALLOC:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = ".result"}
+  // FUNC-REF: %[[VAL:.*]] = fir.call @retcptr() : () -> i64
+  // FUNC-REF: %[[FIELD:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  // FUNC-REF: %[[ADDR:.*]] = fir.coordinate_of %[[ALLOC]], %[[FIELD]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+  // FUNC-REF: fir.store %[[VAL]] to %[[ADDR]] : !fir.ref<i64>
+  // FUNC-BOX: %[[ALLOC:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = ".result"}
+  // FUNC-BOX: %[[VAL:.*]] = fir.call @retcptr() : () -> i64
+  // FUNC-BOX: %[[FIELD:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  // FUNC-BOX: %[[ADDR:.*]] = fir.coordinate_of %[[ALLOC]], %[[FIELD]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+  // FUNC-BOX: fir.store %[[VAL]] to %[[ADDR]] : !fir.ref<i64>
 }
 
 // ------------------------ Test fir.address_of rewrite ------------------------
 
 func.func private @takesfuncarray((i32) -> !fir.array<?xf32>)
 
 // FUNC-REF-LABEL: func @test_address_of() {
 // FUNC-BOX-LABEL: func @test_address_of() {
 func.func @test_address_of() {
   %0 = fir.address_of(@arrayfunc) : (i32) -> !fir.array<?xf32>
   fir.call @takesfuncarray(%0) : ((i32) -> !fir.array<?xf32>) -> ()
   return
 
   // FUNC-REF: %[[addrOf:.*]] = fir.address_of(@arrayfunc) : (!fir.ref<!fir.array<?xf32>>, i32) -> ()
   // FUNC-REF: %[[conv:.*]] = fir.convert %[[addrOf]] : ((!fir.ref<!fir.array<?xf32>>, i32) -> ()) -> ((i32) -> !fir.array<?xf32>)
   // FUNC-REF: fir.call @takesfuncarray(%[[conv]]) : ((i32) -> !fir.array<?xf32>) -> ()
 
   // FUNC-BOX: %[[addrOf:.*]] = fir.address_of(@arrayfunc) : (!fir.box<!fir.array<?xf32>>, i32) -> ()
   // FUNC-BOX: %[[conv:.*]] = fir.convert %[[addrOf]] : ((!fir.box<!fir.array<?xf32>>, i32) -> ()) -> ((i32) -> !fir.array<?xf32>)
   // FUNC-BOX: fir.call @takesfuncarray(%[[conv]]) : ((i32) -> !fir.array<?xf32>) -> ()
 
 }
 
+// FUNC-REF-LABEL: func.func private @returns_null() -> i64
+// FUNC-BOX-LABEL: func.func private @returns_null() -> i64
+func.func private @returns_null() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+
+// FUNC-REF-LABEL: func @test_address_of_cptr
+// FUNC-BOX-LABEL: func @test_address_of_cptr
+func.func @test_address_of_cptr() {
+  %0 = fir.address_of(@returns_null) : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  %1 = fir.convert %0 : (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>) -> (() -> ())
+  fir.call @_QMtest_c_func_modPsubr(%1) : (() -> ()) -> ()
+  return
+
+  // FUNC-REF: %[[VAL_0:.*]] = fir.address_of(@returns_null) : () -> i64
+  // FUNC-REF: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (() -> i64) -> (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>)
+  // FUNC-REF: %[[VAL_2:.*]] = fir.convert %[[VAL_1]] : (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>) -> (() -> ())
+  // FUNC-REF: fir.call @_QMtest_c_func_modPsubr(%[[VAL_2]]) : (() -> ()) -> ()
+  // FUNC-BOX: %[[VAL_0:.*]] = fir.address_of(@returns_null) : () -> i64
+  // FUNC-BOX: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (() -> i64) -> (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>)
+  // FUNC-BOX: %[[VAL_2:.*]] = fir.convert %[[VAL_1]] : (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>) -> (() -> ())
+  // FUNC-BOX: fir.call @_QMtest_c_func_modPsubr(%[[VAL_2]]) : (() -> ()) -> ()
+}
+
+
 // ----------------------- Test indirect calls rewrite ------------------------
 
 // FUNC-REF-LABEL: func @test_indirect_calls(
 // FUNC-REF-SAME: %[[arg0:.*]]: () -> ()) {
 // FUNC-BOX-LABEL: func @test_indirect_calls(
 // FUNC-BOX-SAME: %[[arg0:.*]]: () -> ()) {
 func.func @test_indirect_calls(%arg0: () -> ()) {
   %c100 = arith.constant 100 : index
func.func @test_indirect_calls(%arg0: () -> ()) {
   // FUNC-BOX: %[[shape:.*]] = fir.shape %[[c100]] : (index) -> !fir.shape<1>
   // FUNC-BOX: %[[original_conv:.*]] = fir.convert %[[arg0]] : (() -> ()) -> ((index) -> !fir.array<?xf32>)
   // FUNC-BOX: %[[box:.*]] = fir.embox %[[buffer]](%[[shape]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
   // FUNC-BOX: %[[conv:.*]] = fir.convert %[[original_conv]] : ((index) -> !fir.array<?xf32>) -> ((!fir.box<!fir.array<?xf32>>, index) -> ())
   // FUNC-BOX: fir.call %[[conv]](%[[box]], %c100) : (!fir.box<!fir.array<?xf32>>, index) -> ()
   // FUNC-BOX-NOT: fir.save_result
 }
 
+// FUNC-REF-LABEL: func @test_indirect_calls_return_cptr(
+// FUNC-REF-SAME: %[[ARG0:.*]]: () -> ())
+// FUNC-BOX-LABEL: func @test_indirect_calls_return_cptr(
+// FUNC-BOX-SAME: %[[ARG0:.*]]: () -> ())
+func.func @test_indirect_calls_return_cptr(%arg0: () -> ()) {
+  %0 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = ".result"}
+  %1 = fir.convert %arg0 : (() -> ()) -> (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>)
+  %2 = fir.call %1() : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  fir.save_result %2 to %0 : !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>
+  return
+
+  // FUNC-REF: %[[VAL_0:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = ".result"}
+  // FUNC-REF: %[[VAL_1:.*]] = fir.convert %[[ARG0]] : (() -> ()) -> (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>)
+  // FUNC-REF: %[[VAL_2:.*]] = fir.convert %[[VAL_1]] : (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>) -> (() -> i64)
+  // FUNC-REF: %[[VAL_3:.*]] = fir.call %[[VAL_2]]() : () -> i64
+  // FUNC-REF: %[[VAL_4:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  // FUNC-REF: %[[VAL_5:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_4]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+  // FUNC-REF: fir.store %[[VAL_3]] to %[[VAL_5]] : !fir.ref<i64>
+  // FUNC-BOX: %[[VAL_0:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = ".result"}
+  // FUNC-BOX: %[[VAL_1:.*]] = fir.convert %[[ARG0]] : (() -> ()) -> (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>)
+  // FUNC-BOX: %[[VAL_2:.*]] = fir.convert %[[VAL_1]] : (() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>) -> (() -> i64)
+  // FUNC-BOX: %[[VAL_3:.*]] = fir.call %[[VAL_2]]() : () -> i64
+  // FUNC-BOX: %[[VAL_4:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  // FUNC-BOX: %[[VAL_5:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_4]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+  // FUNC-BOX: fir.store %[[VAL_3]] to %[[VAL_5]] : !fir.ref<i64>
+}
+
 // ----------------------- Test GlobalOp rewrite ------------------------
 
 // This is needed to separate GlobalOp tests from FuncOp tests for FileCheck
 // FUNC-REF-LABEL: fir.global {{.*}} : {{.*}} {
 // FUNC-BOX-LABEL: fir.global {{.*}} : {{.*}} {
 
 // GLOBAL-REF-LABEL: fir.global @global_test_address_of : i32 {
 // GLOBAL-BOX-LABEL: fir.global @global_test_address_of : i32 {