[clang] [CIR] Track flexible array members in record layout and pass to ABI (PR #241158)

via cfe-commits cfe-commits at lists.llvm.org
Tue Nov 10 23:12:48 PST 2026


https://github.com/skc7 created https://github.com/llvm/llvm-project/pull/241158

Summary:

- In CIR, a record which has flexible array member was wrongly classified and passed in register. 
- Classic CodeGen passes them byval and returns them through sret.
- Added `flexible_array_member` to `#cir.record_layout`, set it from `RecordDecl::hasFlexibleArrayMember()` in CIRGen. Mapped it to `RecordFlags::HasFlexibleArrayMember` in the bridge.
- Classic test reference: [amdgpu-abi-struct-coerce.cl](https://github.com/llvm/llvm-project/blob/main/clang/test/CodeGenOpenCL/amdgpu-abi-struct-coerce.cl) ([func_flexible_array_arg](https://github.com/llvm/llvm-project/blob/f1185ef40be8c0d6647e8f70a43f1c963d2d3d46/clang/test/CodeGenOpenCL/amdgpu-abi-struct-coerce.cl#L318), [func_flexible_array_ret](https://github.com/llvm/llvm-project/blob/f1185ef40be8c0d6647e8f70a43f1c963d2d3d46/clang/test/CodeGenOpenCL/amdgpu-abi-struct-coerce.cl#L450)).

Relatest to : https://github.com/llvm/llvm-project/issues/220471

Assisted by: claude opus 5.5

>From e31360a6e3a2df07c113b4448d214748fd484366 Mon Sep 17 00:00:00 2001
From: skc7 <Krishna.Sankisa at amd.com>
Date: Wed, 11 Nov 2026 12:19:13 +0530
Subject: [PATCH] [CIR] Track flexible array members in record layout and pass
 to ABI

---
 .../include/clang/CIR/Dialect/IR/CIRAttrs.td  |  10 +-
 .../CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp |  10 +-
 clang/lib/CIR/Dialect/IR/CIRAttrs.cpp         |  27 ++++-
 .../Dialect/Transforms/CIRABIClassifier.cpp   |   9 ++
 ...call-conv-lowering-x86_64-flexible-array.c |  84 +++++++++++++
 clang/test/CIR/IR/record-layout.cir           |  12 +-
 .../abi-lowering/amdgpu-flexible-array.cir    | 111 ++++++++++++++++++
 .../unittests/CIR/RecordTypeMetadataTest.cpp  |   3 +-
 8 files changed, 251 insertions(+), 15 deletions(-)
 create mode 100644 clang/test/CIR/CodeGen/call-conv-lowering-x86_64-flexible-array.c
 create mode 100644 clang/test/CIR/Transforms/abi-lowering/amdgpu-flexible-array.cir

diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
index 2c00f23bb384c2..29548690b0d666 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
@@ -200,6 +200,10 @@ def CIR_RecordLayoutAttr : CIR_Attr<"RecordLayout", "record_layout", [
     - `transparent_union`: whether the record is a union with
       `__attribute__((transparent_union))`, which is passed as its first
       member.  False, the default, is omitted from the printed form.
+    - `flexible_array_member`: from `RecordDecl::hasFlexibleArrayMember()`,
+      which is also set when the last field is a record that has one.  A
+      zero-length array is not a flexible array member.  False, the default,
+      is omitted from the printed form.
 
     Example:
     ```
@@ -223,7 +227,8 @@ def CIR_RecordLayoutAttr : CIR_Attr<"RecordLayout", "record_layout", [
     "bool":$has_trivial_dtor,
     "uint64_t":$record_align,
     "uint64_t":$unadjusted_align,
-    DefaultValuedParameter<"bool", "false">:$transparent_union
+    DefaultValuedParameter<"bool", "false">:$transparent_union,
+    DefaultValuedParameter<"bool", "false">:$flexible_array_member
   );
 
   let builders = [
@@ -232,7 +237,8 @@ def CIR_RecordLayoutAttr : CIR_Attr<"RecordLayout", "record_layout", [
                      "uint64_t":$record_align), [{
       return $_get($_ctxt, arg_passing_kind, has_trivial_dtor, record_align,
                    /*unadjusted_align=*/record_align,
-                   /*transparent_union=*/false);
+                   /*transparent_union=*/false,
+                   /*flexible_array_member=*/false);
     }]>
   ];
 
diff --git a/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp b/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp
index 2ed7d34320390d..3552f76c7ef44c 100644
--- a/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp
@@ -968,11 +968,11 @@ CIRGenTypes::computeRecordLayout(const RecordDecl *rd, cir::RecordType *ty) {
         astLayout.getUnadjustedAlignment().getQuantity();
     bool isTransparentUnion = rd->hasAttr<TransparentUnionAttr>();
 
-    cgm.addRecordLayout(
-        ty->getName(),
-        cir::RecordLayoutAttr::get(mlirCtx, apk, hasTrivialDestructor,
-                                   recordAlignInBytes, unadjustedAlignInBytes,
-                                   isTransparentUnion));
+    cgm.addRecordLayout(ty->getName(),
+                        cir::RecordLayoutAttr::get(
+                            mlirCtx, apk, hasTrivialDestructor,
+                            recordAlignInBytes, unadjustedAlignInBytes,
+                            isTransparentUnion, rd->hasFlexibleArrayMember()));
   }
 
   auto rl = std::make_unique<CIRGenRecordLayout>(
diff --git a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
index 8f2b1933c6dbba..96f9f82e6ad869 100644
--- a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
@@ -1096,10 +1096,11 @@ Attribute RecordLayoutAttr::parse(AsmParser &parser, Type odsType) {
   if (failed(recordAlign))
     return {};
 
-  // An omitted unadjusted_align stores the record alignment. Either optional
-  // field may follow record_align, in either order.
+  // An omitted unadjusted_align stores the record alignment. The optional
+  // fields may follow record_align in any order.
   uint64_t unadjustedAlign = *recordAlign;
   bool transparentUnion = false;
+  bool flexibleArrayMember = false;
   while (succeeded(parser.parseOptionalComma())) {
     if (succeeded(parser.parseOptionalKeyword("unadjusted_align"))) {
       if (parser.parseEqual())
@@ -1119,16 +1120,26 @@ Attribute RecordLayoutAttr::parse(AsmParser &parser, Type odsType) {
       transparentUnion = *parsed;
       continue;
     }
+    if (succeeded(parser.parseOptionalKeyword("flexible_array_member"))) {
+      if (parser.parseEqual())
+        return {};
+      FailureOr<bool> parsed = FieldParser<bool>::parse(parser);
+      if (failed(parsed))
+        return {};
+      flexibleArrayMember = *parsed;
+      continue;
+    }
     parser.emitError(parser.getCurrentLocation(),
-                     "expected unadjusted_align or transparent_union");
+                     "expected unadjusted_align, transparent_union or "
+                     "flexible_array_member");
     return {};
   }
 
   if (parser.parseGreater())
     return {};
-  return parser.getChecked<RecordLayoutAttr>(loc, parser.getContext(), *kind,
-                                             *hasTrivialDtor, *recordAlign,
-                                             unadjustedAlign, transparentUnion);
+  return parser.getChecked<RecordLayoutAttr>(
+      loc, parser.getContext(), *kind, *hasTrivialDtor, *recordAlign,
+      unadjustedAlign, transparentUnion, flexibleArrayMember);
 }
 
 void RecordLayoutAttr::print(AsmPrinter &printer) const {
@@ -1147,6 +1158,10 @@ void RecordLayoutAttr::print(AsmPrinter &printer) const {
     printer << ", transparent_union = ";
     printer.printStrippedAttrOrType(getTransparentUnion());
   }
+  if (getFlexibleArrayMember()) {
+    printer << ", flexible_array_member = ";
+    printer.printStrippedAttrOrType(getFlexibleArrayMember());
+  }
   printer << '>';
 }
 
diff --git a/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp b/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp
index 2855b5fbe349c7..21d5af11f31fc3 100644
--- a/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp
@@ -54,6 +54,13 @@ static bool recordIsTransparentUnion(ModuleOp modOp, cir::RecordType recTy) {
   return layout && layout.getTransparentUnion();
 }
 
+/// Read from the layout, which also covers a last field that has one.
+static bool recordHasFlexibleArrayMember(ModuleOp modOp,
+                                         cir::RecordType recTy) {
+  auto layout = cir::tryGetRecordLayout(modOp, recTy.getName());
+  return layout && layout.getFlexibleArrayMember();
+}
+
 /// Whether the classifier could give this type the SSEUP class, looking
 /// through arrays and records at the types they hold.
 static bool mayReachSseUp(mlir::Type ty, const DataLayout &dl) {
@@ -393,6 +400,8 @@ static const llvm::abi::Type *mapCIRType(mlir::Type type,
           flags = flags | llvm::abi::RecordFlags::CanPassInRegisters;
         if (recordIsTransparentUnion(modOp, recTy))
           flags = flags | llvm::abi::RecordFlags::IsTransparent;
+        if (recordHasFlexibleArrayMember(modOp, recTy))
+          flags = flags | llvm::abi::RecordFlags::HasFlexibleArrayMember;
         llvm::TypeSize sizeBits = llvm::TypeSize::getFixed(
             dl.getTypeSizeInBits(type).getFixedValue());
         llvm::Align align = recordDeclaredAlign(modOp, recTy, dl);
diff --git a/clang/test/CIR/CodeGen/call-conv-lowering-x86_64-flexible-array.c b/clang/test/CIR/CodeGen/call-conv-lowering-x86_64-flexible-array.c
new file mode 100644
index 00000000000000..0ac51df6435518
--- /dev/null
+++ b/clang/test/CIR/CodeGen/call-conv-lowering-x86_64-flexible-array.c
@@ -0,0 +1,84 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t-cir.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t-cir.ll %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
+
+// A record with a flexible array member is passed and returned in memory.
+// A zero-length array is not a flexible array member and stays in registers.
+
+typedef struct { int n; int data[]; } fam_t;
+typedef struct { int a, b, c; int data[]; } fam_big_t;
+typedef struct { int n; int data[0]; } zla_t;
+typedef struct { int x; fam_t f; } fam_nested_t;
+
+// The nested record gets the flag from its last field. zla_t does not.
+// CIR: cir.record_layouts = {
+// CIR-SAME: fam_big_t = #cir.record_layout<{{[^>]*}}, flexible_array_member = true>
+// CIR-SAME: fam_nested_t = #cir.record_layout<{{[^>]*}}, flexible_array_member = true>
+// CIR-SAME: fam_t = #cir.record_layout<{{[^>]*}}, flexible_array_member = true>
+// CIR-SAME: zla_t = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4>}
+
+void arg_fam(fam_t s) {}
+
+// CIR:      cir.func {{.*}} @arg_fam(%[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_t> {llvm.align = 8 : i64, llvm.byval = !rec_fam_t, llvm.noundef}
+// CIR-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.copy %[[S_ARG]] align(8) to %[[S]] align(4) : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.return implicit
+
+// LLVM: define dso_local void @arg_fam(ptr noundef byval(%struct.fam_t) align 8 %{{.*}})
+
+// Without the flag, 12 bytes would be split into i64 and i32.
+void arg_fam_big(fam_big_t s) {}
+
+// CIR:      cir.func {{.*}} @arg_fam_big(%[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_big_t> {llvm.align = 8 : i64, llvm.byval = !rec_fam_big_t, llvm.noundef}
+// CIR-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_big_t>
+// CIR-NEXT:   cir.copy %[[S_ARG]] align(8) to %[[S]] align(4) : !cir.ptr<!rec_fam_big_t>
+// CIR-NEXT:   cir.return implicit
+
+// LLVM: define dso_local void @arg_fam_big(ptr noundef byval(%struct.fam_big_t) align 8 %{{.*}})
+
+void arg_zla(zla_t s) {}
+
+// CIR:      cir.func {{.*}} @arg_zla(%[[S_ARG:[^:]+]]: !s32i
+// CIR-NEXT:   %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT:   cir.store %[[S_ARG]], %[[COERCE]] : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT:   %[[COERCE_REC:.*]] = cir.cast bitcast %[[COERCE]] : !cir.ptr<!s32i> -> !cir.ptr<!rec_zla_t>
+// CIR-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_zla_t>
+// CIR-NEXT:   cir.copy %[[COERCE_REC]] align(4) to %[[S]] align(4) : !cir.ptr<!rec_zla_t>
+// CIR-NEXT:   cir.return implicit
+
+// LLVM: define dso_local void @arg_zla(i32 %{{.*}})
+
+void arg_fam_nested(fam_nested_t s) {}
+
+// CIR:      cir.func {{.*}} @arg_fam_nested(%[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_nested_t> {llvm.align = 8 : i64, llvm.byval = !rec_fam_nested_t, llvm.noundef}
+// CIR-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_nested_t>
+// CIR-NEXT:   cir.copy %[[S_ARG]] align(8) to %[[S]] align(4) : !cir.ptr<!rec_fam_nested_t>
+// CIR-NEXT:   cir.return implicit
+
+// LLVM: define dso_local void @arg_fam_nested(ptr noundef byval(%struct.fam_nested_t) align 8 %{{.*}})
+
+fam_t ret_fam(fam_t s) { return s; }
+
+// CIR:      cir.func {{.*}} @ret_fam(%[[RET:[^:]+]]: !cir.ptr<!rec_fam_t> {llvm.align = 4 : i64, llvm.dead_on_unwind, llvm.noalias, llvm.sret = !rec_fam_t, llvm.writable} {{.*}}, %[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_t> {llvm.align = 8 : i64, llvm.byval = !rec_fam_t, llvm.noundef}
+// CIR-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.copy %[[S_ARG]] align(8) to %[[S]] align(4) : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.copy %[[S]] align(4) to %[[RET]] align(4) : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.return
+
+// LLVM: define dso_local void @ret_fam(ptr dead_on_unwind noalias writable sret(%struct.fam_t) align 4 %{{.*}}, ptr noundef byval(%struct.fam_t) align 8 %{{.*}})
+
+void call_fam(fam_t s) { arg_fam(s); }
+
+// CIR:      cir.func {{.*}} @call_fam(%[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_t> {llvm.align = 8 : i64, llvm.byval = !rec_fam_t, llvm.noundef}
+// CIR-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.copy %[[S_ARG]] align(8) to %[[S]] align(4) : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   %[[TMP:.*]] = cir.alloca "byval" align(8) : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.copy %[[S]] align(4) to %[[TMP]] align(8) : !cir.ptr<!rec_fam_t>
+// CIR-NEXT:   cir.call @arg_fam(%[[TMP]]) : (!cir.ptr<!rec_fam_t> {llvm.align = 8 : i64, llvm.byval = !rec_fam_t, llvm.noundef}) -> ()
+// CIR-NEXT:   cir.return implicit
+
+// LLVM: define dso_local void @call_fam(ptr noundef byval(%struct.fam_t) align 8 %{{.*}})
+// LLVM:   call void @arg_fam(ptr noundef byval(%struct.fam_t) align 8 %{{.*}})
diff --git a/clang/test/CIR/IR/record-layout.cir b/clang/test/CIR/IR/record-layout.cir
index 321d55bd6cf7f1..a028bff1cd275c 100644
--- a/clang/test/CIR/IR/record-layout.cir
+++ b/clang/test/CIR/IR/record-layout.cir
@@ -10,7 +10,13 @@ module attributes {
                                 unadjusted_align = 4>,
     TU = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
                             has_trivial_dtor = true, record_align = 4,
-                            transparent_union = true>
+                            transparent_union = true>,
+    FAM = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                             has_trivial_dtor = true, record_align = 4,
+                             flexible_array_member = true>,
+    NoFAM = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                               has_trivial_dtor = true, record_align = 4,
+                               flexible_array_member = false>
   }
 } {}
 
@@ -19,3 +25,7 @@ module attributes {
 // CHECK-DAG: Raised = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 16, unadjusted_align = 4>
 // CHECK-DAG: Same = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4>
 // CHECK-DAG: TU = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4, transparent_union = true>
+
+// flexible_array_member is printed only when true.
+// CHECK-DAG: FAM = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4, flexible_array_member = true>
+// CHECK-DAG: NoFAM = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4>{{[,}]}}
diff --git a/clang/test/CIR/Transforms/abi-lowering/amdgpu-flexible-array.cir b/clang/test/CIR/Transforms/abi-lowering/amdgpu-flexible-array.cir
new file mode 100644
index 00000000000000..d1d616a461efed
--- /dev/null
+++ b/clang/test/CIR/Transforms/abi-lowering/amdgpu-flexible-array.cir
@@ -0,0 +1,111 @@
+// RUN: cir-opt %s -cir-call-conv-lowering=target=amdgpu | FileCheck %s
+
+// A record with a flexible array member is passed byval and returned through
+// sret, both in addrspace(5). A zero-length array is not one.
+
+!s32i = !cir.int<s, 32>
+!rec_fam_t = !cir.struct<"fam_t" {data !s32i, data !cir.array<!s32i x 0>}>
+!rec_zla_t = !cir.struct<"zla_t" {data !s32i, empty !cir.array<!s32i x 0>}>
+!rec_fam_nested_t = !cir.struct<"fam_nested_t" {data !s32i, data !rec_fam_t}>
+
+module attributes {
+  cir.record_layouts = {
+    fam_nested_t = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                                      has_trivial_dtor = true, record_align = 4,
+                                      flexible_array_member = true>,
+    fam_t = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                               has_trivial_dtor = true, record_align = 4,
+                               flexible_array_member = true>,
+    zla_t = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                               has_trivial_dtor = true, record_align = 4>},
+  dlti.dl_spec = #dlti.dl_spec<
+    #dlti.dl_entry<i32, dense<32>: vector<2xi64>>,
+    #dlti.dl_entry<i64, dense<64>: vector<2xi64>>,
+    #dlti.dl_entry<"dlti.alloca_memory_space", 5 : ui64>>
+} {
+
+  cir.func @arg_fam(%arg0: !rec_fam_t) requires_call_conv_lowering {
+    %0 = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t, target_address_space(5)>
+    %1 = cir.cast address_space %0 : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+    cir.store %arg0, %1 : !rec_fam_t, !cir.ptr<!rec_fam_t>
+    cir.return
+  }
+
+  // CHECK:      cir.func @arg_fam(%[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_t, target_address_space(5)> {llvm.align = 4 : i64, llvm.byval = !rec_fam_t, llvm.noundef}) {
+  // CHECK-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t, target_address_space(5)>
+  // CHECK-NEXT:   %[[S_VIEW:.*]] = cir.cast address_space %[[S]] : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   cir.copy %[[S_ARG]] align(4) to %[[S_VIEW]] align(4) : !cir.ptr<!rec_fam_t, target_address_space(5)>, !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   cir.return
+  // CHECK-NEXT: }
+
+  // The last field holds a flexible array member, so the record has one too.
+  cir.func @arg_fam_nested(%arg0: !rec_fam_nested_t) requires_call_conv_lowering {
+    %0 = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_nested_t, target_address_space(5)>
+    %1 = cir.cast address_space %0 : !cir.ptr<!rec_fam_nested_t, target_address_space(5)> -> !cir.ptr<!rec_fam_nested_t>
+    cir.store %arg0, %1 : !rec_fam_nested_t, !cir.ptr<!rec_fam_nested_t>
+    cir.return
+  }
+
+  // CHECK:      cir.func @arg_fam_nested(%[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_nested_t, target_address_space(5)> {llvm.align = 4 : i64, llvm.byval = !rec_fam_nested_t, llvm.noundef}) {
+  // CHECK-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_nested_t, target_address_space(5)>
+  // CHECK-NEXT:   %[[S_VIEW:.*]] = cir.cast address_space %[[S]] : !cir.ptr<!rec_fam_nested_t, target_address_space(5)> -> !cir.ptr<!rec_fam_nested_t>
+  // CHECK-NEXT:   cir.copy %[[S_ARG]] align(4) to %[[S_VIEW]] align(4) : !cir.ptr<!rec_fam_nested_t, target_address_space(5)>, !cir.ptr<!rec_fam_nested_t>
+  // CHECK-NEXT:   cir.return
+  // CHECK-NEXT: }
+
+  // A zero-length array holds no data, so the record is packed into an i32.
+  cir.func @arg_zla(%arg0: !rec_zla_t) requires_call_conv_lowering {
+    %0 = cir.alloca "s" align(4) init : !cir.ptr<!rec_zla_t, target_address_space(5)>
+    %1 = cir.cast address_space %0 : !cir.ptr<!rec_zla_t, target_address_space(5)> -> !cir.ptr<!rec_zla_t>
+    cir.store %arg0, %1 : !rec_zla_t, !cir.ptr<!rec_zla_t>
+    cir.return
+  }
+
+  // CHECK:      cir.func @arg_zla(%[[S_ARG:[^:]+]]: !s32i) {
+  // CHECK-NEXT:   %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!s32i, target_address_space(5)>
+  // CHECK-NEXT:   cir.store %[[S_ARG]], %[[COERCE]] : !s32i, !cir.ptr<!s32i, target_address_space(5)>
+  // CHECK-NEXT:   %[[COERCE_REC:.*]] = cir.cast bitcast %[[COERCE]] : !cir.ptr<!s32i, target_address_space(5)> -> !cir.ptr<!rec_zla_t, target_address_space(5)>
+  // CHECK-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_zla_t, target_address_space(5)>
+  // CHECK-NEXT:   %[[S_VIEW:.*]] = cir.cast address_space %[[S]] : !cir.ptr<!rec_zla_t, target_address_space(5)> -> !cir.ptr<!rec_zla_t>
+  // CHECK-NEXT:   cir.copy %[[COERCE_REC]] align(4) to %[[S_VIEW]] align(4) : !cir.ptr<!rec_zla_t, target_address_space(5)>, !cir.ptr<!rec_zla_t>
+  // CHECK-NEXT:   cir.return
+  // CHECK-NEXT: }
+
+  cir.func @ret_fam(%arg0: !rec_fam_t) -> !rec_fam_t requires_call_conv_lowering {
+    %0 = cir.alloca "__retval" align(4) : !cir.ptr<!rec_fam_t, target_address_space(5)>
+    %1 = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t, target_address_space(5)>
+    %2 = cir.cast address_space %1 : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+    %3 = cir.cast address_space %0 : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+    cir.store %arg0, %2 : !rec_fam_t, !cir.ptr<!rec_fam_t>
+    cir.copy %2 align(4) to %3 align(4) : !cir.ptr<!rec_fam_t>
+    %4 = cir.load %0 : !cir.ptr<!rec_fam_t, target_address_space(5)>, !rec_fam_t
+    cir.return %4 : !rec_fam_t
+  }
+
+  // CHECK:      cir.func @ret_fam(%[[RET:[^:]+]]: !cir.ptr<!rec_fam_t, target_address_space(5)> {llvm.align = 4 : i64, llvm.dead_on_unwind, llvm.noalias, llvm.sret = !rec_fam_t, llvm.writable}, %[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_t, target_address_space(5)> {llvm.align = 4 : i64, llvm.byval = !rec_fam_t, llvm.noundef}) {
+  // CHECK-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t, target_address_space(5)>
+  // CHECK-NEXT:   %[[S_VIEW:.*]] = cir.cast address_space %[[S]] : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   %[[RET_VIEW:.*]] = cir.cast address_space %[[RET]] : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   cir.copy %[[S_ARG]] align(4) to %[[S_VIEW]] align(4) : !cir.ptr<!rec_fam_t, target_address_space(5)>, !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   cir.copy %[[S_VIEW]] align(4) to %[[RET_VIEW]] align(4) : !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   cir.return
+  // CHECK-NEXT: }
+
+  cir.func @call_fam(%arg0: !rec_fam_t) requires_call_conv_lowering {
+    %0 = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t, target_address_space(5)>
+    %1 = cir.cast address_space %0 : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+    cir.store %arg0, %1 : !rec_fam_t, !cir.ptr<!rec_fam_t>
+    %2 = cir.load align(4) %1 : !cir.ptr<!rec_fam_t>, !rec_fam_t
+    cir.call @arg_fam(%2) : (!rec_fam_t) -> ()
+    cir.return
+  }
+
+  // The caller's local is passed as the byval pointer.
+  // CHECK:      cir.func @call_fam(%[[S_ARG:[^:]+]]: !cir.ptr<!rec_fam_t, target_address_space(5)> {llvm.align = 4 : i64, llvm.byval = !rec_fam_t, llvm.noundef}) {
+  // CHECK-NEXT:   %[[S:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_fam_t, target_address_space(5)>
+  // CHECK-NEXT:   %[[S_VIEW:.*]] = cir.cast address_space %[[S]] : !cir.ptr<!rec_fam_t, target_address_space(5)> -> !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   cir.copy %[[S_ARG]] align(4) to %[[S_VIEW]] align(4) : !cir.ptr<!rec_fam_t, target_address_space(5)>, !cir.ptr<!rec_fam_t>
+  // CHECK-NEXT:   cir.call @arg_fam(%[[S]]) : (!cir.ptr<!rec_fam_t, target_address_space(5)> {llvm.align = 4 : i64, llvm.byval = !rec_fam_t, llvm.noundef}) -> ()
+  // CHECK-NEXT:   cir.return
+  // CHECK-NEXT: }
+}
diff --git a/clang/unittests/CIR/RecordTypeMetadataTest.cpp b/clang/unittests/CIR/RecordTypeMetadataTest.cpp
index 3c5feb52a8e32b..347ba5a7f33f54 100644
--- a/clang/unittests/CIR/RecordTypeMetadataTest.cpp
+++ b/clang/unittests/CIR/RecordTypeMetadataTest.cpp
@@ -70,7 +70,8 @@ TEST_F(RecordLayoutAttrTest, UnadjustedAlignDefaultsToRecordAlign) {
 TEST_F(RecordLayoutAttrTest, UnadjustedAlignDistinct) {
   auto attr = RecordLayoutAttr::get(&context, ArgPassingKind::CanPassInRegs,
                                     true, 16, /*unadjusted_align=*/4,
-                                    /*transparent_union=*/false);
+                                    /*transparent_union=*/false,
+                                    /*flexible_array_member=*/false);
   EXPECT_EQ(attr.getRecordAlign(), 16u);
   EXPECT_EQ(attr.getUnadjustedAlign(), 4u);
 }



More information about the cfe-commits mailing list