[flang] Add support for lowering intrinsic module procedure C_ASSOCIATED

[peixin]

Summary

As Fortran 2018 18.2.3.2, the arguments of C_ASSOCIATED have the same
type, a scalar of type C_PTR or C_FUNPTR, and the result has the default
logical scalar type. The interface is defined with two module procedures
c_associated_c_ptr/c_associated_c_funptr in flang/module/iso_c_binding.
The result is false if the first argument is a C null pointer. If the
second argument is present, the result is true only if the two arguments
are equal. Support the lowering by comparing the C pointer address
values of two arguments if the second argument is dynamically present
and comparing the C pointer address value of the first argument with the
value 0.

[jeanPerier]

Is this working for the dynamic optional case ? I see the "asValue, handleDynamicOptional" in the table, but I am not sure it is intended for derived types (*), and since the second argument load is unconditional, I wonder if this really works for the test_3 below:

module tests
contains
subroutine test_3(cptr1, cptr2)
  use iso_c_binding
  type(c_ptr) :: cptr1
  type(c_ptr), optional :: cptr2
  print *, c_associated(cptr1, cptr2)
end

subroutine test_3_driver()
  use iso_c_binding
  type(c_ptr) :: cptr1
  integer, target :: i
  cptr1 = c_loc(i)
  call test_3(cptr1)
  call test_3(cptr1, cptr1)
end subroutine
end module

  use tests
  call test_3_driver()
end

I think you might want to use asAddr and check that the second argument address is not null to conditionally load it and compare it.

(*) I think the intent was for this to not even compile according to this assert: https://github.com/llvm/llvm-project/blob/https://github.com/llvm/llvm-project/commit/dfcc0a70cc5d2fb8d2687105e9b9745dbf6a5cda/flang/lib/Lower/ConvertExpr.cpp#L431

[peixin]

Rebase due to conflict.

[peixin]

In D136419#3879078, @jeanPerier wrote:

Is this working for the dynamic optional case ? I see the "asValue, handleDynamicOptional" in the table, but I am not sure it is intended for derived types (*), and since the second argument load is unconditional, I wonder if this really works for the test_3 below:

module tests
contains
subroutine test_3(cptr1, cptr2)
  use iso_c_binding
  type(c_ptr) :: cptr1
  type(c_ptr), optional :: cptr2
  print *, c_associated(cptr1, cptr2)
end

subroutine test_3_driver()
  use iso_c_binding
  type(c_ptr) :: cptr1
  integer, target :: i
  cptr1 = c_loc(i)
  call test_3(cptr1)
  call test_3(cptr1, cptr1)
end subroutine
end module

  use tests
  call test_3_driver()
end

I think you might want to use asAddr and check that the second argument address is not null to conditionally load it and compare it.

(*) I think the intent was for this to not even compile according to this assert: https://github.com/llvm/llvm-project/blob/https://github.com/llvm/llvm-project/commit/dfcc0a70cc5d2fb8d2687105e9b9745dbf6a5cda/flang/lib/Lower/ConvertExpr.cpp#L431

You are right. I missed the possibility of dynamic optional argument. Fixed as suggested. Thanks a lot.

[jeanPerier]

LGTM, thanks

flang/include/flang/Optimizer/Builder/FIRBuilder.h

mlir::Value genMaxWithZero(fir::FirOpBuilder &builder, mlir::Location loc,
                            mlir::Value value);
 
 /// The type(C_PTR/C_FUNPTR) is defined as the derived type with only one
 /// component of integer 64, and the component is the C address. Get the C
 /// address.
 mlir::Value genCPtrOrCFunptrAddr(fir::FirOpBuilder &builder, mlir::Location loc,
                                  mlir::Value cPtr, mlir::Type ty);
 
+/// Get the C address value.
+mlir::Value genCPtrOrCFunptrValue(fir::FirOpBuilder &builder,
+                                  mlir::Location loc, mlir::Value cPtr);
+
 /// Create a fir.box from a fir::ExtendedValue and wrap it in a fir::BoxValue
 /// to keep all the lower bound and explicit parameter information.
 fir::BoxValue createBoxValue(fir::FirOpBuilder &builder, mlir::Location loc,
                              const fir::ExtendedValue &exv);
 } // namespace fir::factory
 
 #endif // FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H

flang/lib/Lower/IntrinsicCall.cpp

struct IntrinsicLibrary {
   template <mlir::arith::CmpIPredicate pred>
   fir::ExtendedValue genCharacterCompare(mlir::Type,
                                          llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genCmplx(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genConjg(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genCount(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   void genCpuTime(llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genCshift(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+  fir::ExtendedValue genCAssociatedCFunPtr(mlir::Type,
+                                           llvm::ArrayRef<fir::ExtendedValue>);
+  fir::ExtendedValue genCAssociatedCPtr(mlir::Type,
+                                        llvm::ArrayRef<fir::ExtendedValue>);
   void genCFPointer(llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genCFunLoc(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genCLoc(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   void genDateAndTime(llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genDim(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genDotProduct(mlir::Type,
                                    llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genDprod(mlir::Type, llvm::ArrayRef<mlir::Value>);
static constexpr IntrinsicHandler handlers[]{
      &I::genAssociated,
      {{{"pointer", asInquired}, {"target", asInquired}}},
      /*isElemental=*/false},
     {"bge", &I::genBitwiseCompare<mlir::arith::CmpIPredicate::uge>},
     {"bgt", &I::genBitwiseCompare<mlir::arith::CmpIPredicate::ugt>},
     {"ble", &I::genBitwiseCompare<mlir::arith::CmpIPredicate::ule>},
     {"blt", &I::genBitwiseCompare<mlir::arith::CmpIPredicate::ult>},
     {"btest", &I::genBtest},
+    {"c_associated_c_funptr",
+     &I::genCAssociatedCFunPtr,
+     {{{"c_ptr_1", asAddr}, {"c_ptr_2", asAddr, handleDynamicOptional}}},
+     /*isElemental=*/false},
+    {"c_associated_c_ptr",
+     &I::genCAssociatedCPtr,
+     {{{"c_ptr_1", asAddr}, {"c_ptr_2", asAddr, handleDynamicOptional}}},
+     /*isElemental=*/false},
     {"c_f_pointer",
      &I::genCFPointer,
      {{{"cptr", asValue},
        {"fptr", asInquired},
        {"shape", asAddr, handleDynamicOptional}}},
      /*isElemental=*/false},
     {"c_funloc", &I::genCFunLoc, {{{"x", asBox}}}, /*isElemental=*/false},
     {"c_loc", &I::genCLoc, {{{"x", asBox}}}, /*isElemental=*/false},
argAddr = builder.create<fir::BoxAddrOp>(loc, box->getMemTy(),
                                              fir::getBase(*box));
   }
   mlir::Value argAddrVal = builder.createConvert(
       loc, fir::unwrapRefType(resAddr.getType()), argAddr);
   builder.create<fir::StoreOp>(loc, argAddrVal, resAddr);
   return res;
 }
 
+/// C_ASSOCIATED
+static fir::ExtendedValue
+genCAssociated(fir::FirOpBuilder &builder, mlir::Location loc,
+               mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args) {
+  assert(args.size() == 2);
+  mlir::Value cPtr1 = fir::getBase(args[0]);
+  mlir::Value cPtrVal1 =
+      fir::factory::genCPtrOrCFunptrValue(builder, loc, cPtr1);
+  mlir::Value zero = builder.createIntegerConstant(loc, cPtrVal1.getType(), 0);
+  mlir::Value res = builder.create<mlir::arith::CmpIOp>(
+      loc, mlir::arith::CmpIPredicate::ne, cPtrVal1, zero);
+
+  if (isStaticallyPresent(args[1])) {
+    mlir::Type i1Ty = builder.getI1Type();
+    mlir::Value cPtr2 = fir::getBase(args[1]);
+    mlir::Value isDynamicallyAbsent = builder.genIsNullAddr(loc, cPtr2);
+    res =
+        builder
+            .genIfOp(loc, {i1Ty}, isDynamicallyAbsent, /*withElseRegion=*/true)
+            .genThen([&]() { builder.create<fir::ResultOp>(loc, res); })
+            .genElse([&]() {
+              mlir::Value cPtrVal2 =
+                  fir::factory::genCPtrOrCFunptrValue(builder, loc, cPtr2);
+              mlir::Value cmpVal = builder.create<mlir::arith::CmpIOp>(
+                  loc, mlir::arith::CmpIPredicate::eq, cPtrVal1, cPtrVal2);
+              mlir::Value newRes =
+                  builder.create<mlir::arith::AndIOp>(loc, res, cmpVal);
+              builder.create<fir::ResultOp>(loc, newRes);
+            })
+            .getResults()[0];
+  }
+  return builder.createConvert(loc, resultType, res);
+}
+
+/// C_ASSOCIATED (C_FUNPTR [, C_FUNPTR])
+fir::ExtendedValue IntrinsicLibrary::genCAssociatedCFunPtr(
+    mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args) {
+  return genCAssociated(builder, loc, resultType, args);
+}
+
+/// C_ASSOCIATED (C_PTR [, C_PTR])
+fir::ExtendedValue
+IntrinsicLibrary::genCAssociatedCPtr(mlir::Type resultType,
+                                     llvm::ArrayRef<fir::ExtendedValue> args) {
+  return genCAssociated(builder, loc, resultType, args);
+}
+
 // C_F_POINTER
 void IntrinsicLibrary::genCFPointer(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 3);
   // Handle CPTR argument
   // Get the value of the C address or the result of a reference to C_LOC.
   mlir::Value cPtr = fir::getBase(args[0]);
-  mlir::Type cPtrTy = fir::unwrapRefType(cPtr.getType());
-  mlir::Value cPtrAddr =
-      fir::factory::genCPtrOrCFunptrAddr(builder, loc, cPtr, cPtrTy);
-  mlir::Value cPtrAddrVal = builder.create<fir::LoadOp>(loc, cPtrAddr);
+  mlir::Value cPtrAddrVal =
+      fir::factory::genCPtrOrCFunptrValue(builder, loc, cPtr);
 
   // Handle FPTR argument
   const auto *fPtr = args[1].getBoxOf<fir::MutableBoxValue>();
   assert(fPtr && "FPTR must be a pointer");
 
   auto getCPtrExtVal = [&](fir::MutableBoxValue box) -> fir::ExtendedValue {
     mlir::Value addr =
         builder.createConvert(loc, fPtr->getMemTy(), cPtrAddrVal);

flang/lib/Optimizer/Builder/FIRBuilder.cpp

exv.match(
       },
       [&](const fir::MutableBoxValue &x) {
         explicitTypeParams.append(x.nonDeferredLenParams().begin(),
                                   x.nonDeferredLenParams().end());
       },
       [](const auto &) {});
   return fir::BoxValue(box, lbounds, explicitTypeParams);
 }
+
+mlir::Value fir::factory::genCPtrOrCFunptrValue(fir::FirOpBuilder &builder,
+                                                mlir::Location loc,
+                                                mlir::Value cPtr) {
+  mlir::Type cPtrTy = fir::unwrapRefType(cPtr.getType());
+  mlir::Value cPtrAddr =
+      fir::factory::genCPtrOrCFunptrAddr(builder, loc, cPtr, cPtrTy);
+  return builder.create<fir::LoadOp>(loc, cPtrAddr);
+}

flang/test/Lower/Intrinsics/c_associated.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+
+! Test intrinsic module procedure c_associated
+
+! CHECK-LABEL: func.func @_QPtest_c_ptr(
+! CHECK-SAME:                           %[[VAL_0:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>> {fir.bindc_name = "cptr1"},
+! CHECK-SAME:                           %[[VAL_1:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>> {fir.bindc_name = "cptr2"}) {
+! CHECK:         %[[VAL_2:.*]] = fir.alloca !fir.logical<4> {bindc_name = "z1", uniq_name = "_QFtest_c_ptrEz1"}
+! CHECK:         %[[VAL_3:.*]] = fir.alloca !fir.logical<4> {bindc_name = "z2", uniq_name = "_QFtest_c_ptrEz2"}
+! CHECK:         %[[VAL_4:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+! CHECK:         %[[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>
+! CHECK:         %[[VAL_6:.*]] = fir.load %[[VAL_5]] : !fir.ref<i64>
+! CHECK:         %[[VAL_7:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_8:.*]] = arith.cmpi ne, %[[VAL_6]], %[[VAL_7]] : i64
+! CHECK:         %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i1) -> !fir.logical<4>
+! CHECK:         fir.store %[[VAL_9]] to %[[VAL_2]] : !fir.ref<!fir.logical<4>>
+! CHECK:         %[[VAL_10:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+! CHECK:         %[[VAL_11:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_10]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:         %[[VAL_12:.*]] = fir.load %[[VAL_11]] : !fir.ref<i64>
+! CHECK:         %[[VAL_13:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_14:.*]] = arith.cmpi ne, %[[VAL_12]], %[[VAL_13]] : i64
+! CHECK:         %[[VAL_15:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>) -> i64
+! CHECK:         %[[VAL_16:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_17:.*]] = arith.cmpi eq, %[[VAL_15]], %[[VAL_16]] : i64
+! CHECK:         %[[VAL_18:.*]] = fir.if %[[VAL_17]] -> (i1) {
+! CHECK:           fir.result %[[VAL_14]] : i1
+! CHECK:         } else {
+! CHECK:           %[[VAL_19:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+! CHECK:           %[[VAL_20:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_19]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:           %[[VAL_21:.*]] = fir.load %[[VAL_20]] : !fir.ref<i64>
+! CHECK:           %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_12]], %[[VAL_21]] : i64
+! CHECK:           %[[VAL_23:.*]] = arith.andi %[[VAL_14]], %[[VAL_22]] : i1
+! CHECK:           fir.result %[[VAL_23]] : i1
+! CHECK:         }
+! CHECK:         %[[VAL_24:.*]] = fir.convert %[[VAL_25:.*]] : (i1) -> !fir.logical<4>
+! CHECK:         fir.store %[[VAL_24]] to %[[VAL_3]] : !fir.ref<!fir.logical<4>>
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_c_ptr(cptr1, cptr2)
+  use iso_c_binding
+  type(c_ptr) :: cptr1, cptr2
+  logical :: z1, z2
+
+  z1 = c_associated(cptr1)
+
+  z2 = c_associated(cptr1, cptr2)
+end
+
+! CHECK-LABEL: func.func @_QPtest_c_funptr(
+! CHECK-SAME:                              %[[VAL_0:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>> {fir.bindc_name = "cptr1"},
+! CHECK-SAME:                              %[[VAL_1:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>> {fir.bindc_name = "cptr2"}) {
+! CHECK:         %[[VAL_2:.*]] = fir.alloca !fir.logical<4> {bindc_name = "z1", uniq_name = "_QFtest_c_funptrEz1"}
+! CHECK:         %[[VAL_3:.*]] = fir.alloca !fir.logical<4> {bindc_name = "z2", uniq_name = "_QFtest_c_funptrEz2"}
+! CHECK:         %[[VAL_4:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>
+! CHECK:         %[[VAL_5:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_4]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:         %[[VAL_6:.*]] = fir.load %[[VAL_5]] : !fir.ref<i64>
+! CHECK:         %[[VAL_7:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_8:.*]] = arith.cmpi ne, %[[VAL_6]], %[[VAL_7]] : i64
+! CHECK:         %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i1) -> !fir.logical<4>
+! CHECK:         fir.store %[[VAL_9]] to %[[VAL_2]] : !fir.ref<!fir.logical<4>>
+! CHECK:         %[[VAL_10:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>
+! CHECK:         %[[VAL_11:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_10]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:         %[[VAL_12:.*]] = fir.load %[[VAL_11]] : !fir.ref<i64>
+! CHECK:         %[[VAL_13:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_14:.*]] = arith.cmpi ne, %[[VAL_12]], %[[VAL_13]] : i64
+! CHECK:         %[[VAL_15:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>>) -> i64
+! CHECK:         %[[VAL_16:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_17:.*]] = arith.cmpi eq, %[[VAL_15]], %[[VAL_16]] : i64
+! CHECK:         %[[VAL_18:.*]] = fir.if %[[VAL_17]] -> (i1) {
+! CHECK:           fir.result %[[VAL_14]] : i1
+! CHECK:         } else {
+! CHECK:           %[[VAL_19:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>
+! CHECK:           %[[VAL_20:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_19]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:           %[[VAL_21:.*]] = fir.load %[[VAL_20]] : !fir.ref<i64>
+! CHECK:           %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_12]], %[[VAL_21]] : i64
+! CHECK:           %[[VAL_23:.*]] = arith.andi %[[VAL_14]], %[[VAL_22]] : i1
+! CHECK:           fir.result %[[VAL_23]] : i1
+! CHECK:         }
+! CHECK:         %[[VAL_24:.*]] = fir.convert %[[VAL_25:.*]] : (i1) -> !fir.logical<4>
+! CHECK:         fir.store %[[VAL_24]] to %[[VAL_3]] : !fir.ref<!fir.logical<4>>
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_c_funptr(cptr1, cptr2)
+  use iso_c_binding
+  type(c_funptr) :: cptr1, cptr2
+  logical :: z1, z2
+
+  z1 = c_associated(cptr1)
+
+  z2 = c_associated(cptr1, cptr2)
+end
+
+! CHECK-LABEL: func.func @_QPtest_optional_argument(
+! CHECK-SAME:                                       %[[VAL_0:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>> {fir.bindc_name = "cptr1"},
+! CHECK-SAME:                                       %[[VAL_1:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>> {fir.bindc_name = "cptr2", fir.optional},
+! CHECK-SAME:                                       %[[VAL_2:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>> {fir.bindc_name = "cfunptr1"},
+! CHECK-SAME:                                       %[[VAL_3:.*]]: !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>> {fir.bindc_name = "cfunptr2", fir.optional}) {
+! CHECK:         %[[VAL_4:.*]] = fir.alloca !fir.logical<4> {bindc_name = "z1", uniq_name = "_QFtest_optional_argumentEz1"}
+! CHECK:         %[[VAL_5:.*]] = fir.alloca !fir.logical<4> {bindc_name = "z2", uniq_name = "_QFtest_optional_argumentEz2"}
+! CHECK:         %[[VAL_6:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+! CHECK:         %[[VAL_7:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_6]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:         %[[VAL_8:.*]] = fir.load %[[VAL_7]] : !fir.ref<i64>
+! CHECK:         %[[VAL_9:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_10:.*]] = arith.cmpi ne, %[[VAL_8]], %[[VAL_9]] : i64
+! CHECK:         %[[VAL_11:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>) -> i64
+! CHECK:         %[[VAL_12:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_13:.*]] = arith.cmpi eq, %[[VAL_11]], %[[VAL_12]] : i64
+! CHECK:         %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (i1) {
+! CHECK:           fir.result %[[VAL_10]] : i1
+! CHECK:         } else {
+! CHECK:           %[[VAL_15:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+! CHECK:           %[[VAL_16:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_15]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:           %[[VAL_17:.*]] = fir.load %[[VAL_16]] : !fir.ref<i64>
+! CHECK:           %[[VAL_18:.*]] = arith.cmpi eq, %[[VAL_8]], %[[VAL_17]] : i64
+! CHECK:           %[[VAL_19:.*]] = arith.andi %[[VAL_10]], %[[VAL_18]] : i1
+! CHECK:           fir.result %[[VAL_19]] : i1
+! CHECK:         }
+! CHECK:         %[[VAL_20:.*]] = fir.convert %[[VAL_21:.*]] : (i1) -> !fir.logical<4>
+! CHECK:         fir.store %[[VAL_20]] to %[[VAL_4]] : !fir.ref<!fir.logical<4>>
+! CHECK:         %[[VAL_22:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>
+! CHECK:         %[[VAL_23:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_22]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:         %[[VAL_24:.*]] = fir.load %[[VAL_23]] : !fir.ref<i64>
+! CHECK:         %[[VAL_25:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_26:.*]] = arith.cmpi ne, %[[VAL_24]], %[[VAL_25]] : i64
+! CHECK:         %[[VAL_27:.*]] = fir.convert %[[VAL_3]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>>) -> i64
+! CHECK:         %[[VAL_28:.*]] = arith.constant 0 : i64
+! CHECK:         %[[VAL_29:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_28]] : i64
+! CHECK:         %[[VAL_30:.*]] = fir.if %[[VAL_29]] -> (i1) {
+! CHECK:           fir.result %[[VAL_26]] : i1
+! CHECK:         } else {
+! CHECK:           %[[VAL_31:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>
+! CHECK:           %[[VAL_32:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_31]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
+! CHECK:           %[[VAL_33:.*]] = fir.load %[[VAL_32]] : !fir.ref<i64>
+! CHECK:           %[[VAL_34:.*]] = arith.cmpi eq, %[[VAL_24]], %[[VAL_33]] : i64
+! CHECK:           %[[VAL_35:.*]] = arith.andi %[[VAL_26]], %[[VAL_34]] : i1
+! CHECK:           fir.result %[[VAL_35]] : i1
+! CHECK:         }
+! CHECK:         %[[VAL_36:.*]] = fir.convert %[[VAL_37:.*]] : (i1) -> !fir.logical<4>
+! CHECK:         fir.store %[[VAL_36]] to %[[VAL_5]] : !fir.ref<!fir.logical<4>>
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_optional_argument(cptr1, cptr2, cfunptr1, cfunptr2)
+  use iso_c_binding
+  type(c_ptr) :: cptr1
+  type(c_ptr), optional :: cptr2
+  type(c_funptr) :: cfunptr1
+  type(c_funptr), optional :: cfunptr2
+  logical :: z1, z2
+
+  z1 = c_associated(cptr1, cptr2)
+
+  z2 = c_associated(cfunptr1, cfunptr2)
+end