[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