[flang] Initial support of lowering derived type passed by value

[peixin]

Summary

This initially supports the lowering of derived type passed by value,
which is for the derived type with value attribute and interoperable
with C. The argument passing must be consistent with the ABI in clang,
which is defined in clang/lib/CodeGen/TargetInfo.cpp.

The initial support only contains the AArch64::AAPCS on non-windows OS.
The function result type is not covered in this patch. This patch adds
functions to compute the size and alignment of the derived type on
AArch64, which should be replaced by one general target-diagnostic way.

[peixin]

For a discussion today: https://github.com/llvm/llvm-project/issues/57002.

[peixin]

Add --target=aarch64-unknown-linux-gnu and ! REQUIRES: shell.

[tschuett]

Or https://discourse.llvm.org/t/rfc-targetinfo-library/64342.

[clementval]

As Jean mentioned during our last call, this is done too early. It is better to perform this in the code gen.

[peixin]

In D131391#3711899, @clementval wrote:

As Jean mentioned during our last call, this is done too early. It is better to perform this in the code gen.

Right. After converting to LLVM type for the derived type during code gen, there are some helper functions which can be used such as llvm::IRBuilderBase builder.GetInsertBlock()->getModule()->getDataLayout().getTypeStoreSize(type). I haven't found the function to handle the the alignment, but there should be.

BTW, I found out that the test case when building HDF5 is type(C_PTR), which is different from the usual derived type since the component is the C address, and the ABI for it is different from that for the usual derived type. So, currently I don't need to implement the whole feature. Instead, I plan to support the scenario in HDF5 first and am working on it.

flang/include/flang/Lower/CallInterface.h

 
 /// Is it required to pass \p proc as a tuple<function address, result length> ?
 // This is required to convey  the length of character functions passed as dummy
 // procedures.
 bool mustPassLengthWithDummyProcedure(
     const Fortran::evaluate::ProcedureDesignator &proc,
     Fortran::lower::AbstractConverter &);
 
+/// Translate the type for derived type passed by value.
+mlir::Type classifyDerivedValueArgumentType(Fortran::lower::AbstractConverter &,
+                                            mlir::Type);
+
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_FIRBUILDER_H

flang/lib/Lower/CallInterface.cpp

 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/Support/Utils.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
+#include "llvm/ADT/Triple.h"
 
 //===----------------------------------------------------------------------===//
 // BIND(C) mangling helpers
 //===----------------------------------------------------------------------===//
 
 // Return the binding label (from BIND(C...)) or the mangled name of a symbol.
 static std::string getMangledName(mlir::Location loc,
                                   const Fortran::semantics::Symbol &symbol) {
if (obj.attrs.test(Attrs::Allocatable) || obj.attrs.test(Attrs::Pointer)) {
       // Pass as fir.ref unless it's by VALUE and BIND(C)
       mlir::Type passType = fir::ReferenceType::get(type);
       PassEntityBy passBy = PassEntityBy::BaseAddress;
       Property prop = Property::BaseAddress;
       if (isValueAttr) {
         if (isBindC) {
           passBy = PassEntityBy::Value;
           prop = Property::Value;
+          if (fir::isa_derived(type))
+            passType = Fortran::lower::classifyDerivedValueArgumentType(
+                interface.converter, type);
+          else
             passType = type;
         } else {
           passBy = PassEntityBy::BaseAddressValueAttribute;
         }
       }
       addFirOperand(passType, nextPassedArgPosition(), prop, attrs);
       addPassedArg(passBy, entity, characteristics);
     }
   }
std::optional<Fortran::evaluate::characteristics::Procedure> iface =
       Fortran::evaluate::characteristics::Procedure::Characterize(
           dummyProc, converter.getFoldingContext());
   mlir::Type procType = getProcedureDesignatorType(
       iface.has_value() ? &*iface : nullptr, converter);
   if (::mustPassLengthWithDummyProcedure(iface))
     return fir::factory::getCharacterProcedureTupleType(procType);
   return procType;
 }
+
+//===--------------------------------------------------------------------===//
+// ABI helpers of a call or function for argument and return type conversion.
+// This is for dervied type passed by value (interoperable with C) for now.
+// The derived type cannot have type parameters, TBP, pointer or allocatables.
+// That is, the drived type has compile-time known size.
+// Note:
+//   This must be consistent with ABI info in clang/lib/CodeGen/TargetInfo.cpp.
+//===--------------------------------------------------------------------===//
+
+static inline bool
+isAArch64HomogeneousAggregateSmallEnough(std::uint64_t members) {
+  return members <= 4;
+}
+
+static inline bool isAArch64HomogeneousAggregateBaseType(mlir::Type ty) {
+  return fir::isa_real(ty);
+}
+
+static bool isAArch64HomogeneousAggregate(mlir::Type ty, mlir::Type &base,
+                                          std::uint64_t &members) {
+  if (ty.isa<fir::SequenceType>()) {
+    auto seqTy = ty.dyn_cast<fir::SequenceType>();
+    assert(!seqTy.hasDynamicExtents() &&
+           "unexpected dynamic size for interoperable derived type component");
+    std::uint64_t nElements = 1;
+    for (unsigned i = 0; i < seqTy.getDimension(); ++i)
+      nElements *= seqTy.getShape()[i];
+    if (nElements == 0)
+      return false;
+    if (!isAArch64HomogeneousAggregate(seqTy.getEleTy(), base, members))
+      return false;
+    members *= nElements;
+  } else if (auto recTy = ty.dyn_cast_or_null<fir::RecordType>()) {
+    members = 0;
+    for (int i = 0; i < (int)recTy.getTypeList().size(); ++i) {
+      mlir::Type fieldTy = recTy.getTypeList()[i].second;
+      while (fieldTy.isa<fir::SequenceType>()) {
+        auto seqTy = fieldTy.dyn_cast<fir::SequenceType>();
+        assert(
+            !seqTy.hasDynamicExtents() &&
+            "unexpected dynamic size for interoperable derived type component");
+        std::uint64_t nElements = 1;
+        for (unsigned j = 0; j < seqTy.getDimension(); ++j)
+          nElements *= seqTy.getShape()[j];
+        if (nElements == 0)
+          return false;
+        fieldTy = seqTy.getEleTy();
+      }
+
+      if (auto fieldRecTy = fieldTy.dyn_cast_or_null<fir::RecordType>())
+        if (fieldRecTy.getNumFields() == 0)
+          continue;
+
+      std::uint64_t fieldMembers;
+      if (!isAArch64HomogeneousAggregate(recTy.getTypeList()[i].second, base,
+                                         fieldMembers))
+        return false;
+
+      members = members + fieldMembers;
+    }
+    if (!base)
+      return false;
+  } else {
+    members = 1;
+    if (auto cplx = ty.dyn_cast_or_null<fir::ComplexType>()) {
+      members = 2;
+      ty = cplx.getElementType();
+    }
+
+    if (!isAArch64HomogeneousAggregateBaseType(ty))
+      return false;
+
+    if (!base)
+      base = ty;
+  }
+  return members > 0 && isAArch64HomogeneousAggregateSmallEnough(members);
+}
+
+static std::uint64_t getScalarSize(mlir::Type scalarTy, std::uint64_t &elems) {
+  std::uint64_t scalarSize = 0;
+  if (fir::isa_integer(scalarTy) || fir::isa_real(scalarTy)) {
+    scalarSize = scalarTy.getIntOrFloatBitWidth();
+  } else if (auto cplx = scalarTy.dyn_cast_or_null<fir::ComplexType>()) {
+    scalarSize = 8 * cplx.getFKind();
+    elems = 2 * elems;
+  } else if (auto lgTy = scalarTy.dyn_cast_or_null<fir::LogicalType>()) {
+    assert(lgTy.getFKind() == 1);
+    scalarSize = 1;
+  } else if (auto ct = scalarTy.dyn_cast_or_null<fir::CharacterType>()) {
+    // FIXME: gfortran does not support length more than 1, ifort supports.
+    assert(ct.getLen() == 1 && ct.getFKind() == 1);
+    scalarSize = 1;
+  }
+  return scalarSize;
+}
+
+// FIXME: Replace this with a known target-dependent function.
+static std::uint64_t getAArch64DerivedTypeSize(mlir::Type ty,
+                                               std::uint64_t &align) {
+  assert(fir::isa_derived(ty));
+  auto recTy = ty.dyn_cast<fir::RecordType>();
+  std::uint64_t size = 0;
+  std::uint64_t lastFieldSize = 0;
+  std::uint64_t aggregateSize = 0;
+
+  for (int i = 0; i < (int)recTy.getTypeList().size(); ++i) {
+    mlir::Type fieldTy = recTy.getTypeList()[i].second;
+    std::uint64_t nElements = 1;
+    std::uint64_t fieldAlignSize = 0;
+    if (fir::isa_derived(fieldTy)) {
+      std::uint64_t dtSize = getAArch64DerivedTypeSize(fieldTy, fieldAlignSize);
+      nElements = dtSize / fieldAlignSize;
+    } else if (auto seqTy = fieldTy.dyn_cast_or_null<fir::SequenceType>()) {
+      for (unsigned i = 0; i < seqTy.getDimension(); ++i)
+        nElements *= seqTy.getShape()[i];
+      if (nElements == 0) {
+        fieldAlignSize = 0;
+        continue;
+      } else {
+        mlir::Type seqEleTy = seqTy.getEleTy();
+        if (fir::isa_derived(seqEleTy)) {
+          std::uint64_t dtSize =
+              getAArch64DerivedTypeSize(seqEleTy, fieldAlignSize);
+          nElements = dtSize / fieldAlignSize * nElements;
+        } else {
+          fieldAlignSize = getScalarSize(seqEleTy, nElements);
+        }
+      }
+    } else {
+      fieldAlignSize = getScalarSize(fieldTy, nElements);
+    }
+    if (lastFieldSize < fieldAlignSize)
+      aggregateSize = (aggregateSize + fieldAlignSize - 1) / fieldAlignSize *
+                      fieldAlignSize;
+    if (fieldAlignSize > align) {
+      align = fieldAlignSize;
+      aggregateSize = (aggregateSize + nElements * fieldAlignSize + align - 1) /
+                      align * align;
+    } else {
+      aggregateSize += nElements * fieldAlignSize;
+    }
+    size = (aggregateSize + align - 1) / align * align;
+  }
+  return size;
+}
+
+// FIXME: Replace this with a known target-dependent function.
+static std::uint64_t getAArch64UnjustedTypeAlign(mlir::Type ty) {
+  assert(fir::isa_derived(ty));
+  auto recTy = ty.dyn_cast<fir::RecordType>();
+  std::uint64_t align = 0;
+  std::uint64_t fieldAlignSize = 0;
+  for (int i = 0; i < (int)recTy.getTypeList().size(); ++i) {
+    mlir::Type fieldTy = recTy.getTypeList()[i].second;
+    std::uint64_t nElements = 1;
+    if (fir::isa_derived(fieldTy)) {
+      (void)getAArch64DerivedTypeSize(fieldTy, fieldAlignSize);
+    } else if (auto seqTy = fieldTy.dyn_cast_or_null<fir::SequenceType>()) {
+      for (unsigned i = 0; i < seqTy.getDimension(); ++i)
+        nElements *= seqTy.getShape()[i];
+      if (nElements == 0) {
+        fieldAlignSize = 0;
+      } else {
+        mlir::Type seqEleTy = seqTy.getEleTy();
+        if (fir::isa_derived(seqEleTy))
+          (void)getAArch64DerivedTypeSize(seqEleTy, fieldAlignSize);
+        else
+          fieldAlignSize = getScalarSize(seqEleTy, nElements);
+      }
+    } else {
+      fieldAlignSize = getScalarSize(fieldTy, nElements);
+    }
+    align = std::max(align, fieldAlignSize);
+  }
+  return align;
+}
+
+static mlir::Type
+classifyAArch64ArgumentType(Fortran::lower::AbstractConverter &converter,
+                            mlir::Type ty) {
+  assert(fir::isa_derived(ty));
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+
+  mlir::Type base;
+  std::uint64_t members = 0;
+  if (isAArch64HomogeneousAggregate(ty, base, members)) {
+    fir::SequenceType::Shape shape(1, members);
+    return fir::SequenceType::get(shape, base);
+  }
+
+  std::uint64_t align = 0;
+  std::uint64_t size = getAArch64DerivedTypeSize(ty, align);
+  if (size <= 128) {
+    std::uint64_t align = getAArch64UnjustedTypeAlign(ty);
+    // FIXME: Use max(align, pointerwidth()) for non-AAPCS.
+    align = align < 128 ? 64 : 128;
+    size = (size + align - 1) / align * align;
+
+    mlir::Type baseTy = builder.getIntegerType(align);
+    if (size == align)
+      return baseTy;
+    fir::SequenceType::Shape shape(1, size / align);
+    return fir::SequenceType::get(shape, baseTy);
+  }
+
+  return fir::ReferenceType::get(ty);
+}
+
+mlir::Type Fortran::lower::classifyDerivedValueArgumentType(
+    Fortran::lower::AbstractConverter &converter, mlir::Type ty) {
+  assert(fir::isa_derived(ty));
+  mlir::ModuleOp module = converter.getModuleOp();
+  llvm::Triple triple = fir::getTargetTriple(module);
+  mlir::Location loc = converter.getCurrentLocation();
+
+  auto recTy = ty.dyn_cast<fir::RecordType>();
+  if (recTy.getNumFields() == 0)
+    TODO(loc, "derived type without component is not interoperable with C");
+
+  if (triple.isAArch64()) {
+    if (triple.isOSWindows())
+      TODO(loc, "derived type passed by value on aarch64 windows");
+    return classifyAArch64ArgumentType(converter, ty);
+  }
+
+  TODO(loc, "derived type passed by value on non-aarch64");
+  return {};
+}

flang/lib/Lower/ConvertExpr.cpp

ExtValue genProcedureRef(const Fortran::evaluate::ProcedureRef &procRef,
     // or pointer variable on the caller side (see 8.5.3 note 1 for
     // allocatables). The few context where this can happen must call
     // genRawProcedureRef directly.
     if (const auto *box = res.getBoxOf<fir::MutableBoxValue>())
       return fir::factory::genMutableBoxRead(builder, getLoc(), *box);
     return res;
   }
 
+  static mlir::Value
+  genDerivedValueArg(Fortran::lower::AbstractConverter &converter,
+                     mlir::Value val, mlir::Type ty) {
+    if (ty.isa<fir::ReferenceType>())
+      return val;
+    fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+    mlir::Location loc = converter.getCurrentLocation();
+    mlir::Value cast =
+        builder.createConvert(loc, fir::ReferenceType::get(ty), val);
+    return builder.create<fir::LoadOp>(loc, cast);
+  }
+
   /// Given a call site for which the arguments were already lowered, generate
   /// the call and return the result. This function deals with explicit result
   /// allocation and lowering if needed. It also deals with passing the host
   /// link to internal procedures.
   ExtValue genCallOpAndResult(Fortran::lower::CallerInterface &caller,
                               mlir::FunctionType callSiteType,
                               llvm::Optional<mlir::Type> resultType) {
     mlir::Location loc = getLoc();
for (auto [fst, snd] :
         auto boxProcTy = builder.getBoxProcType(funcTy);
         if (mlir::Value host = argumentHostAssocs(converter, fst)) {
           cast = builder.create<fir::EmboxProcOp>(
               loc, boxProcTy, llvm::ArrayRef<mlir::Value>{fst, host});
         } else {
           cast = builder.create<fir::EmboxProcOp>(loc, boxProcTy, fst);
         }
       } else {
-        if (fir::isa_derived(snd)) {
-          // FIXME: This seems like a serious bug elsewhere in lowering. Paper
-          // over the problem for now.
-          TODO(loc, "derived type argument passed by value");
-        }
-        assert(!fir::isa_derived(snd));
+        mlir::Type fromTy = fst.getType();
+        if (fromTy.isa<fir::ReferenceType>() &&
+            fir::isa_derived(fir::unwrapRefType(fromTy)) &&
+            ((snd.isa<fir::ReferenceType>() &&
+              fir::isa_derived(fir::unwrapRefType(snd))) ||
+             fir::isa_integer(snd) || snd.isa<fir::SequenceType>())) {
+          cast = genDerivedValueArg(converter, fst, snd);
+        } else {
           cast = builder.convertWithSemantics(loc, snd, fst,
                                               callingImplicitInterface);
         }
+      }
       operands.push_back(cast);
     }
 
     // Add host associations as necessary.
     if (addHostAssociations)
       operands.push_back(converter.hostAssocTupleValue());
 
     auto call = builder.create<fir::CallOp>(loc, funcType.getResults(),

flang/test/Lower/structure-pass-by-value.f90

+! Test lowering of derived type passed by value.
+! RUN: flang-new -fc1 -emit-fir --target=aarch64-unknown-linux-gnu %s -o - | FileCheck %s
+! REQUIRES: shell
+
+! CHECK-LABEL: func.func @_QPderived_pass_by_value1() {
+! CHECK:         %[[VAL_0:.*]] = fir.alloca !fir.type<_QFderived_pass_by_value1Tt1{i:f32,j:i32}> {bindc_name = "my_t1", uniq_name = "_QFderived_pass_by_value1Emy_t1"}
+! CHECK:         %[[VAL_7:.*]] = fir.alloca !fir.type<_QFderived_pass_by_value1Tt2{t1_obj1:!fir.type<_QFderived_pass_by_value1Tt1{i:f32,j:i32}>,x:i64}> {bindc_name = "my_t2", uniq_name = "_QFderived_pass_by_value1Emy_t2"}
+! CHECK:         %[[VAL_14:.*]] = fir.alloca !fir.type<_QFderived_pass_by_value1Tt3{t1_obj2:!fir.type<_QFderived_pass_by_value1Tt1{i:f32,j:i32}>,x:!fir.array<2xi64>}> {bindc_name = "my_t3", uniq_name = "_QFderived_pass_by_value1Emy_t3"}
+! CHECK:         %[[VAL_21:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.type<_QFderived_pass_by_value1Tt1{i:f32,j:i32}>>) -> !fir.ref<i64>
+! CHECK:         %[[VAL_22:.*]] = fir.load %[[VAL_21]] : !fir.ref<i64>
+! CHECK:         %[[VAL_23:.*]] = fir.convert %[[VAL_7]] : (!fir.ref<!fir.type<_QFderived_pass_by_value1Tt2{t1_obj1:!fir.type<_QFderived_pass_by_value1Tt1{i:f32,j:i32}>,x:i64}>>) -> !fir.ref<!fir.array<2xi64>>
+! CHECK:         %[[VAL_24:.*]] = fir.load %[[VAL_23]] : !fir.ref<!fir.array<2xi64>>
+! CHECK:         fir.call @c_func_(%[[VAL_22]], %[[VAL_24]], %[[VAL_14]]) : (i64, !fir.array<2xi64>, !fir.ref<!fir.type<_QFderived_pass_by_value1Tt3{t1_obj2:!fir.type<_QFderived_pass_by_value1Tt1{i:f32,j:i32}>,x:!fir.array<2xi64>}>>) -> ()
+! CHECK:         return
+! CHECK:       }
+
+subroutine derived_pass_by_value1()
+  type, bind(c) :: t1
+    real :: i = -1.
+    integer :: j = -2
+  end type t1
+  type, bind(c) :: t2
+    type(t1) :: t1_obj1
+    integer(8) :: x = 1
+  end type t2
+  type, bind(c) :: t3
+    type(t1) :: t1_obj2
+    integer(8) :: x(2) = [1, 2]
+  end type t3
+  type(t1) :: my_t1
+  type(t2) :: my_t2
+  type(t3) :: my_t3
+  
+  INTERFACE
+     subroutine c_func(c_t1, c_t2, c_t3) BIND(C, NAME='c_func_')
+       import :: t1, t2, t3
+       type(t1), value :: c_t1
+       type(t2), value :: c_t2
+       type(t3), value :: c_t3
+     END
+  END INTERFACE
+
+  call c_func(my_t1, my_t2, my_t3)
+end
+
+! CHECK-LABEL: func.func @_QPderived_pass_by_value2() {
+! CHECK:         %[[VAL_0:.*]] = fir.alloca !fir.type<_QFderived_pass_by_value2Tt1{i:!fir.array<4xf64>}> {bindc_name = "my_t1", uniq_name = "_QFderived_pass_by_value2Emy_t1"}
+! CHECK:         %[[VAL_7:.*]] = fir.alloca !fir.type<_QFderived_pass_by_value2Tt2{x:!fir.array<4xi32>}> {bindc_name = "my_t2", uniq_name = "_QFderived_pass_by_value2Emy_t2"}
+! CHECK:         %[[VAL_14:.*]] = fir.alloca !fir.type<_QFderived_pass_by_value2Tt3{y:!fir.array<2xf32>,z:!fir.complex<4>}> {bindc_name = "my_t3", uniq_name = "_QFderived_pass_by_value2Emy_t3"}
+! CHECK:         %[[VAL_21:.*]] = fir.alloca !fir.type<_QFderived_pass_by_value2Tt4{w:!fir.array<5xf32>}> {bindc_name = "my_t4", uniq_name = "_QFderived_pass_by_value2Emy_t4"}
+! CHECK:         %[[VAL_28:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.type<_QFderived_pass_by_value2Tt1{i:!fir.array<4xf64>}>>) -> !fir.ref<!fir.array<4xf64>>
+! CHECK:         %[[VAL_29:.*]] = fir.load %[[VAL_28]] : !fir.ref<!fir.array<4xf64>>
+! CHECK:         %[[VAL_30:.*]] = fir.convert %[[VAL_7]] : (!fir.ref<!fir.type<_QFderived_pass_by_value2Tt2{x:!fir.array<4xi32>}>>) -> !fir.ref<!fir.array<2xi64>>
+! CHECK:         %[[VAL_31:.*]] = fir.load %[[VAL_30]] : !fir.ref<!fir.array<2xi64>>
+! CHECK:         %[[VAL_32:.*]] = fir.convert %[[VAL_14]] : (!fir.ref<!fir.type<_QFderived_pass_by_value2Tt3{y:!fir.array<2xf32>,z:!fir.complex<4>}>>) -> !fir.ref<!fir.array<4xf32>>
+! CHECK:         %[[VAL_33:.*]] = fir.load %[[VAL_32]] : !fir.ref<!fir.array<4xf32>>
+! CHECK:         fir.call @c_func2_(%[[VAL_29]], %[[VAL_31]], %[[VAL_33]], %[[VAL_21]]) : (!fir.array<4xf64>, !fir.array<2xi64>, !fir.array<4xf32>, !fir.ref<!fir.type<_QFderived_pass_by_value2Tt4{w:!fir.array<5xf32>}>>) -> ()
+! CHECK:         return
+! CHECK:       }
+
+subroutine derived_pass_by_value2()
+  type, bind(c) :: t1
+    real(8) :: i(4) = [-1., -2., -3., -4.]
+  end type t1
+  type, bind(c) :: t2
+    integer :: x(4) = [1, 2, 3, 4]
+  end type t2
+  type, bind(c) :: t3
+    real :: y(2) = [1., 2.]
+    complex :: z = (3., 4.)
+  end type t3
+  type, bind(c) :: t4
+    real :: w(5) = [1., 2., 3., 4., 5.]
+  end type t4
+  type(t1) :: my_t1
+  type(t2) :: my_t2
+  type(t3) :: my_t3
+  type(t4) :: my_t4
+  
+  INTERFACE
+     subroutine c_func2(c_t1, c_t2, c_t3, c_t4) BIND(C, NAME='c_func2_')
+       import :: t1, t2, t3, t4
+       type(t1), value :: c_t1
+       type(t2), value :: c_t2
+       type(t3), value :: c_t3
+       type(t4), value :: c_t4
+     END
+  END INTERFACE
+
+  call c_func2(my_t1, my_t2, my_t3, my_t4)
+end
+
+! CHECK:       func.func private @c_func_(i64, !fir.array<2xi64>, !fir.ref<!fir.type<_QFderived_pass_by_value1Tt3{t1_obj2:!fir.type<_QFderived_pass_by_value1Tt1{i:f32,j:i32}>,x:!fir.array<2xi64>}>>) attributes {fir.bindc_name = "c_func_"}
+! CHECK:       func.func private @c_func2_(!fir.array<4xf64>, !fir.array<2xi64>, !fir.array<4xf32>, !fir.ref<!fir.type<_QFderived_pass_by_value2Tt4{w:!fir.array<5xf32>}>>) attributes {fir.bindc_name = "c_func2_"}