[clang] [CIR] Flatten one-field structs in CallConvLowering (PR #241190)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 12 00:45:13 PST 2026
https://github.com/skc7 updated https://github.com/llvm/llvm-project/pull/241190
>From 2830d8897bdb245abf6b580ede1d6d8b5980c9c8 Mon Sep 17 00:00:00 2001
From: skc7 <Krishna.Sankisa at amd.com>
Date: Wed, 11 Nov 2026 14:57:59 +0530
Subject: [PATCH 1/2] [CIR] Flatten one-field structs in CallConvLowering
---
.../TargetLowering/CIRABIRewriteContext.cpp | 10 +-
.../abi-lowering/amdgpu-one-field-struct.cir | 162 ++++++++++++++++++
2 files changed, 165 insertions(+), 7 deletions(-)
create mode 100644 clang/test/CIR/Transforms/abi-lowering/amdgpu-one-field-struct.cir
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
index 9425df3f8e058..c31da3709b408 100644
--- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
@@ -93,14 +93,13 @@ cir::PointerType getIndirectPtrTy(mlir::Type pointee,
/// 1. The classification is Direct with a non-null coercedType.
/// 2. canFlatten is set.
/// 3. The coercedType is a struct (not a union).
-/// 4. The struct has more than one field (single-field structs are already
-/// scalar; flattening them produces no benefit and classic CodeGen skips
-/// them for the same reason).
+/// 4. The struct has at least one field. A struct of one field is passed as
+/// that field.
cir::RecordType getFlattenedCoercedType(const ArgClassification &ac) {
if (ac.kind != ArgKind::Direct || !ac.coercedType || !ac.canFlatten)
return {};
auto recTy = dyn_cast<cir::RecordType>(ac.coercedType);
- if (!recTy || !recTy.isStruct() || recTy.getNumElements() <= 1)
+ if (!recTy || !recTy.isStruct() || recTy.getMembers().empty())
return {};
return recTy;
}
@@ -134,8 +133,6 @@ buildNewArgTypes(ArrayRef<mlir::Type> oldArgTypes,
case ArgKind::Direct:
// Direct with canFlatten and a struct coerced type: push one wire type
// per field of the coerced struct rather than the struct itself.
- // Single-field coerced structs fall through to the non-flatten path —
- // the struct is already scalar-sized and flattening adds no value.
if (cir::RecordType flatTy = getFlattenedCoercedType(ac)) {
llvm::append_range(newArgTypes, flatTy.getMembers());
} else {
@@ -1258,7 +1255,6 @@ insertArgCoercion(mlir::FunctionOpInterface funcOp,
// slot sized and aligned for both the coerced struct and the original
// argument type, which the body then reads.
unsigned numFields = flatTy.getNumElements();
- assert(numFields >= 2 && "getFlattenedCoercedType guarantees >1 fields");
Type origTy = blockArg.getType();
Location loc = funcOp.getLoc();
diff --git a/clang/test/CIR/Transforms/abi-lowering/amdgpu-one-field-struct.cir b/clang/test/CIR/Transforms/abi-lowering/amdgpu-one-field-struct.cir
new file mode 100644
index 0000000000000..0159c6729dd7d
--- /dev/null
+++ b/clang/test/CIR/Transforms/abi-lowering/amdgpu-one-field-struct.cir
@@ -0,0 +1,162 @@
+// RUN: cir-opt %s -cir-call-conv-lowering=target=amdgpu | FileCheck %s
+
+// A struct of one aggregate field is not a single-element struct, so AMDGPU
+// passes it Direct with no coerce type. The argument is passed as that field.
+// A return is not flattened and stays whole.
+
+!s32i = !cir.int<s, 32>
+!rec_cdwrap_t = !cir.struct<"cdwrap_t" {data !cir.complex<!cir.double>}>
+!rec_arrwrap_t = !cir.struct<"arrwrap_t" {data !cir.array<!s32i x 3>}>
+!rec_inner = !cir.struct<"inner" {data !s32i, data !s32i, data !s32i}>
+!rec_nestwrap_t = !cir.struct<"nestwrap_t" {data !rec_inner}>
+!rec_triple_t = !cir.struct<"triple_t" {data !s32i, data !s32i, data !s32i}>
+
+module attributes {
+ 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<f64, dense<64>: vector<2xi64>>,
+ #dlti.dl_entry<"dlti.alloca_memory_space", 5 : ui64>>
+} {
+
+ // The complex field is passed in place of the struct.
+ cir.func @arg_cdwrap(%arg0: !rec_cdwrap_t) requires_call_conv_lowering {
+ %0 = cir.alloca "w" align(8) init : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ %1 = cir.cast address_space %0 : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+ cir.store %arg0, %1 : !rec_cdwrap_t, !cir.ptr<!rec_cdwrap_t>
+ cir.return
+ }
+
+ // CHECK: cir.func @arg_cdwrap(%[[ARG:.*]]: !cir.complex<!cir.double>) {
+ // CHECK-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+ // CHECK-NEXT: %[[W:.*]] = cir.alloca "w" align(8) init : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W_CAST:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+ // CHECK-NEXT: cir.copy %[[COERCE]] align(8) to %[[W_CAST]] align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>, !cir.ptr<!rec_cdwrap_t>
+ // CHECK-NEXT: cir.return
+
+ // The array field is passed in place of the struct.
+ cir.func @arg_arrwrap(%arg0: !rec_arrwrap_t) requires_call_conv_lowering {
+ %0 = cir.alloca "w" align(4) init : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>
+ %1 = cir.cast address_space %0 : !cir.ptr<!rec_arrwrap_t, target_address_space(5)> -> !cir.ptr<!rec_arrwrap_t>
+ cir.store %arg0, %1 : !rec_arrwrap_t, !cir.ptr<!rec_arrwrap_t>
+ cir.return
+ }
+
+ // CHECK: cir.func @arg_arrwrap(%[[ARG:.*]]: !cir.array<!s32i x 3>) {
+ // CHECK-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_arrwrap_t, target_address_space(5)> -> !cir.ptr<!cir.array<!s32i x 3>, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>, target_address_space(5)>
+ // CHECK-NEXT: %[[W:.*]] = cir.alloca "w" align(4) init : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W_CAST:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_arrwrap_t, target_address_space(5)> -> !cir.ptr<!rec_arrwrap_t>
+ // CHECK-NEXT: cir.copy %[[COERCE]] align(4) to %[[W_CAST]] align(4) : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>, !cir.ptr<!rec_arrwrap_t>
+ // CHECK-NEXT: cir.return
+
+ // The inner struct is passed whole, not split into its three ints.
+ cir.func @arg_nestwrap(%arg0: !rec_nestwrap_t) requires_call_conv_lowering {
+ %0 = cir.alloca "w" align(4) init : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+ %1 = cir.cast address_space %0 : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<!rec_nestwrap_t>
+ cir.store %arg0, %1 : !rec_nestwrap_t, !cir.ptr<!rec_nestwrap_t>
+ cir.return
+ }
+
+ // CHECK: cir.func @arg_nestwrap(%[[ARG:.*]]: !rec_inner) {
+ // CHECK-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<!rec_inner, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[ARG]], %[[FIELD]] : !rec_inner, !cir.ptr<!rec_inner, target_address_space(5)>
+ // CHECK-NEXT: %[[W:.*]] = cir.alloca "w" align(4) init : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W_CAST:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<!rec_nestwrap_t>
+ // CHECK-NEXT: cir.copy %[[COERCE]] align(4) to %[[W_CAST]] align(4) : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>, !cir.ptr<!rec_nestwrap_t>
+ // CHECK-NEXT: cir.return
+
+ // A struct of three ints is split into three arguments.
+ cir.func @arg_triple(%arg0: !rec_triple_t) requires_call_conv_lowering {
+ %0 = cir.alloca "w" align(4) init : !cir.ptr<!rec_triple_t, target_address_space(5)>
+ %1 = cir.cast address_space %0 : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!rec_triple_t>
+ cir.store %arg0, %1 : !rec_triple_t, !cir.ptr<!rec_triple_t>
+ cir.return
+ }
+
+ // CHECK: cir.func @arg_triple(%[[A0:[^:]+]]: !s32i, %[[A1:[^:]+]]: !s32i, %[[A2:[^:]+]]: !s32i) {
+ // CHECK-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_triple_t, target_address_space(5)>
+ // CHECK-NEXT: %[[F0:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!s32i, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[A0]], %[[F0]] : !s32i, !cir.ptr<!s32i, target_address_space(5)>
+ // CHECK-NEXT: %[[F1:.*]] = cir.get_member %[[COERCE]][1] {name = ""} : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!s32i, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[A1]], %[[F1]] : !s32i, !cir.ptr<!s32i, target_address_space(5)>
+ // CHECK-NEXT: %[[F2:.*]] = cir.get_member %[[COERCE]][2] {name = ""} : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!s32i, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[A2]], %[[F2]] : !s32i, !cir.ptr<!s32i, target_address_space(5)>
+ // CHECK-NEXT: %[[W:.*]] = cir.alloca "w" align(4) init : !cir.ptr<!rec_triple_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W_CAST:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!rec_triple_t>
+ // CHECK-NEXT: cir.copy %[[COERCE]] align(4) to %[[W_CAST]] align(4) : !cir.ptr<!rec_triple_t, target_address_space(5)>, !cir.ptr<!rec_triple_t>
+ // CHECK-NEXT: cir.return
+
+ // The caller loads the array field and passes it.
+ cir.func @call_arrwrap(%arg0: !rec_arrwrap_t) requires_call_conv_lowering {
+ %0 = cir.alloca "w" align(4) init : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>
+ %1 = cir.cast address_space %0 : !cir.ptr<!rec_arrwrap_t, target_address_space(5)> -> !cir.ptr<!rec_arrwrap_t>
+ cir.store %arg0, %1 : !rec_arrwrap_t, !cir.ptr<!rec_arrwrap_t>
+ %2 = cir.load align(4) %1 : !cir.ptr<!rec_arrwrap_t>, !rec_arrwrap_t
+ cir.call @arg_arrwrap(%2) : (!rec_arrwrap_t) -> ()
+ cir.return
+ }
+
+ // CHECK: cir.func @call_arrwrap(%[[ARG:.*]]: !cir.array<!s32i x 3>) {
+ // CHECK-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_arrwrap_t, target_address_space(5)> -> !cir.ptr<!cir.array<!s32i x 3>, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>, target_address_space(5)>
+ // CHECK-NEXT: %[[W:.*]] = cir.alloca "w" align(4) init : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W_CAST:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_arrwrap_t, target_address_space(5)> -> !cir.ptr<!rec_arrwrap_t>
+ // CHECK-NEXT: cir.copy %[[COERCE]] align(4) to %[[W_CAST]] align(4) : !cir.ptr<!rec_arrwrap_t, target_address_space(5)>, !cir.ptr<!rec_arrwrap_t>
+ // CHECK-NEXT: %[[W_FIELD:.*]] = cir.get_member %[[W_CAST]][0] {name = ""} : !cir.ptr<!rec_arrwrap_t> -> !cir.ptr<!cir.array<!s32i x 3>>
+ // CHECK-NEXT: %[[ARR:.*]] = cir.load %[[W_FIELD]] : !cir.ptr<!cir.array<!s32i x 3>>, !cir.array<!s32i x 3>
+ // CHECK-NEXT: cir.call @arg_arrwrap(%[[ARR]]) : (!cir.array<!s32i x 3>) -> ()
+ // CHECK-NEXT: cir.return
+
+ // The caller loads the inner struct and passes it.
+ cir.func @call_nestwrap(%arg0: !rec_nestwrap_t) requires_call_conv_lowering {
+ %0 = cir.alloca "w" align(4) init : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+ %1 = cir.cast address_space %0 : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<!rec_nestwrap_t>
+ cir.store %arg0, %1 : !rec_nestwrap_t, !cir.ptr<!rec_nestwrap_t>
+ %2 = cir.load align(4) %1 : !cir.ptr<!rec_nestwrap_t>, !rec_nestwrap_t
+ cir.call @arg_nestwrap(%2) : (!rec_nestwrap_t) -> ()
+ cir.return
+ }
+
+ // CHECK: cir.func @call_nestwrap(%[[ARG:.*]]: !rec_inner) {
+ // CHECK-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<!rec_inner, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[ARG]], %[[FIELD]] : !rec_inner, !cir.ptr<!rec_inner, target_address_space(5)>
+ // CHECK-NEXT: %[[W:.*]] = cir.alloca "w" align(4) init : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W_CAST:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<!rec_nestwrap_t>
+ // CHECK-NEXT: cir.copy %[[COERCE]] align(4) to %[[W_CAST]] align(4) : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>, !cir.ptr<!rec_nestwrap_t>
+ // CHECK-NEXT: %[[W_FIELD:.*]] = cir.get_member %[[W_CAST]][0] {name = ""} : !cir.ptr<!rec_nestwrap_t> -> !cir.ptr<!rec_inner>
+ // CHECK-NEXT: %[[INNER:.*]] = cir.load %[[W_FIELD]] : !cir.ptr<!rec_inner>, !rec_inner
+ // CHECK-NEXT: cir.call @arg_nestwrap(%[[INNER]]) : (!rec_inner) -> ()
+ // CHECK-NEXT: cir.return
+
+ // The argument is passed as its field, but the return stays the struct.
+ cir.func @ret_cdwrap(%arg0: !rec_cdwrap_t) -> !rec_cdwrap_t requires_call_conv_lowering {
+ %0 = cir.alloca "__retval" align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ %1 = cir.alloca "w" align(8) init : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ %2 = cir.cast address_space %1 : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+ %3 = cir.cast address_space %0 : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+ cir.store %arg0, %2 : !rec_cdwrap_t, !cir.ptr<!rec_cdwrap_t>
+ cir.copy %2 align(8) to %3 align(8) : !cir.ptr<!rec_cdwrap_t>
+ %4 = cir.load %0 : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>, !rec_cdwrap_t
+ cir.return %4 : !rec_cdwrap_t
+ }
+
+ // CHECK: cir.func @ret_cdwrap(%[[ARG:.*]]: !cir.complex<!cir.double>) -> !rec_cdwrap_t {
+ // CHECK-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+ // CHECK-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+ // CHECK-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W:.*]] = cir.alloca "w" align(8) init : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+ // CHECK-NEXT: %[[W_CAST:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+ // CHECK-NEXT: %[[RETVAL_CAST:.*]] = cir.cast address_space %[[RETVAL]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+ // CHECK-NEXT: cir.copy %[[COERCE]] align(8) to %[[W_CAST]] align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>, !cir.ptr<!rec_cdwrap_t>
+ // CHECK-NEXT: cir.copy %[[W_CAST]] align(8) to %[[RETVAL_CAST]] align(8) : !cir.ptr<!rec_cdwrap_t>
+ // CHECK-NEXT: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>, !rec_cdwrap_t
+ // CHECK-NEXT: cir.return %[[RET]] : !rec_cdwrap_t
+}
>From e6c80802a293232f8431b65a114592eea4d6ab1b Mon Sep 17 00:00:00 2001
From: skc7 <Krishna.Sankisa at amd.com>
Date: Thu, 12 Nov 2026 14:13:59 +0530
Subject: [PATCH 2/2] add source test
---
...ll-conv-lowering-amdgpu-one-field-struct.c | 116 ++++++++++++++++++
1 file changed, 116 insertions(+)
create mode 100644 clang/test/CIR/CodeGen/call-conv-lowering-amdgpu-one-field-struct.c
diff --git a/clang/test/CIR/CodeGen/call-conv-lowering-amdgpu-one-field-struct.c b/clang/test/CIR/CodeGen/call-conv-lowering-amdgpu-one-field-struct.c
new file mode 100644
index 0000000000000..3c5dd7a242927
--- /dev/null
+++ b/clang/test/CIR/CodeGen/call-conv-lowering-amdgpu-one-field-struct.c
@@ -0,0 +1,116 @@
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -fclangir -emit-cir %s -o %t.cir
+// RUN: cir-opt %t.cir -cir-call-conv-lowering=target=amdgpu -o %t-ccl.cir
+// RUN: FileCheck --input-file=%t-ccl.cir %s --check-prefix=CIR
+// RUN: cir-translate %t-ccl.cir -cir-to-llvmir -o %t-cir.ll
+// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefix=LLVM
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+
+// A struct whose only field is an aggregate is passed as that field.
+
+typedef struct { int i[4]; } single_array_element_struct_arg_t;
+typedef struct { _Complex double c; } cdwrap_t;
+typedef struct { struct { int a, b, c; } t; } nestwrap_t;
+typedef struct { int a, b, c; } triple_t;
+
+// CIR: ![[ANON:rec_anon[^ ]*]] = !cir.struct<"anon{{[^"]*}}" {data !s32i, data !s32i, data !s32i}>
+// CIR: !rec_nestwrap_t = !cir.struct<"nestwrap_t" {data ![[ANON]]}>
+
+// The array field is passed in place of the struct.
+void func_single_array_element_struct_arg(single_array_element_struct_arg_t arg1) {}
+
+// CIR: cir.func{{.*}} @func_single_array_element_struct_arg(%[[ARG:.*]]: !cir.array<!s32i x 4>)
+// CIR-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)>
+// CIR-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)> -> !cir.ptr<!cir.array<!s32i x 4>, target_address_space(5)>
+// CIR-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.array<!s32i x 4>, !cir.ptr<!cir.array<!s32i x 4>, target_address_space(5)>
+// CIR-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" align(4) init : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)>
+// CIR-NEXT: %[[ARG1_VIEW:.*]] = cir.cast address_space %[[ARG1]] : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)> -> !cir.ptr<!rec_single_array_element_struct_arg_t>
+// CIR-NEXT: cir.copy %[[COERCE]] align(4) to %[[ARG1_VIEW]] align(4) : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)>, !cir.ptr<!rec_single_array_element_struct_arg_t>
+// CIR-NEXT: cir.return
+
+// LLVM: define dso_local void @func_single_array_element_struct_arg([4 x i32] %{{.*}})
+
+// The complex field is passed in place of the struct.
+void arg_cdwrap(cdwrap_t w) {}
+
+// CIR: cir.func{{.*}} @arg_cdwrap(%[[ARG:.*]]: !cir.complex<!cir.double>)
+// CIR-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+// CIR-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+// CIR-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+// CIR-NEXT: %[[W:.*]] = cir.alloca "w" align(8) init : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+// CIR-NEXT: %[[W_VIEW:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+// CIR-NEXT: cir.copy %[[COERCE]] align(8) to %[[W_VIEW]] align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>, !cir.ptr<!rec_cdwrap_t>
+// CIR-NEXT: cir.return
+
+// LLVM: define dso_local void @arg_cdwrap({ double, double } %{{.*}})
+
+// The inner struct is passed whole, not split into its three ints.
+void arg_nestwrap(nestwrap_t w) {}
+
+// CIR: cir.func{{.*}} @arg_nestwrap(%[[ARG:.*]]: ![[ANON]])
+// CIR-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+// CIR-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<![[ANON]], target_address_space(5)>
+// CIR-NEXT: cir.store %[[ARG]], %[[FIELD]] : ![[ANON]], !cir.ptr<![[ANON]], target_address_space(5)>
+// CIR-NEXT: %[[W:.*]] = cir.alloca "w" align(4) init : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>
+// CIR-NEXT: %[[W_VIEW:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_nestwrap_t, target_address_space(5)> -> !cir.ptr<!rec_nestwrap_t>
+// CIR-NEXT: cir.copy %[[COERCE]] align(4) to %[[W_VIEW]] align(4) : !cir.ptr<!rec_nestwrap_t, target_address_space(5)>, !cir.ptr<!rec_nestwrap_t>
+// CIR-NEXT: cir.return
+
+// LLVM: define dso_local void @arg_nestwrap(%struct.anon{{.*}} %{{.*}})
+
+// A struct of three ints is split into three arguments.
+void arg_triple(triple_t w) {}
+
+// CIR: cir.func{{.*}} @arg_triple(%[[A:[^:]+]]: !s32i, %[[B:[^:]+]]: !s32i, %[[C:[^:]+]]: !s32i)
+// CIR-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_triple_t, target_address_space(5)>
+// CIR-NEXT: %[[A_PTR:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!s32i, target_address_space(5)>
+// CIR-NEXT: cir.store %[[A]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i, target_address_space(5)>
+// CIR-NEXT: %[[B_PTR:.*]] = cir.get_member %[[COERCE]][1] {name = ""} : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!s32i, target_address_space(5)>
+// CIR-NEXT: cir.store %[[B]], %[[B_PTR]] : !s32i, !cir.ptr<!s32i, target_address_space(5)>
+// CIR-NEXT: %[[C_PTR:.*]] = cir.get_member %[[COERCE]][2] {name = ""} : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!s32i, target_address_space(5)>
+// CIR-NEXT: cir.store %[[C]], %[[C_PTR]] : !s32i, !cir.ptr<!s32i, target_address_space(5)>
+// CIR-NEXT: %[[W:.*]] = cir.alloca "w" align(4) init : !cir.ptr<!rec_triple_t, target_address_space(5)>
+// CIR-NEXT: %[[W_VIEW:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_triple_t, target_address_space(5)> -> !cir.ptr<!rec_triple_t>
+// CIR-NEXT: cir.copy %[[COERCE]] align(4) to %[[W_VIEW]] align(4) : !cir.ptr<!rec_triple_t, target_address_space(5)>, !cir.ptr<!rec_triple_t>
+// CIR-NEXT: cir.return
+
+// LLVM: define dso_local void @arg_triple(i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
+
+// The caller passes the array field.
+void call_single_array(single_array_element_struct_arg_t a) {
+ func_single_array_element_struct_arg(a);
+}
+
+// CIR: cir.func{{.*}} @call_single_array(%[[ARG:.*]]: !cir.array<!s32i x 4>)
+// CIR-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(4) : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)>
+// CIR-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)> -> !cir.ptr<!cir.array<!s32i x 4>, target_address_space(5)>
+// CIR-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.array<!s32i x 4>, !cir.ptr<!cir.array<!s32i x 4>, target_address_space(5)>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)>
+// CIR-NEXT: %[[A_VIEW:.*]] = cir.cast address_space %[[A]] : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)> -> !cir.ptr<!rec_single_array_element_struct_arg_t>
+// CIR-NEXT: cir.copy %[[COERCE]] align(4) to %[[A_VIEW]] align(4) : !cir.ptr<!rec_single_array_element_struct_arg_t, target_address_space(5)>, !cir.ptr<!rec_single_array_element_struct_arg_t>
+// CIR-NEXT: %[[A_FIELD:.*]] = cir.get_member %[[A_VIEW]][0] {name = ""} : !cir.ptr<!rec_single_array_element_struct_arg_t> -> !cir.ptr<!cir.array<!s32i x 4>>
+// CIR-NEXT: %[[A_ARR:.*]] = cir.load %[[A_FIELD]] : !cir.ptr<!cir.array<!s32i x 4>>, !cir.array<!s32i x 4>
+// CIR-NEXT: cir.call @func_single_array_element_struct_arg(%[[A_ARR]]) {convergent} : (!cir.array<!s32i x 4>) -> ()
+// CIR-NEXT: cir.return
+
+// LLVM: define dso_local void @call_single_array([4 x i32] %{{.*}})
+// LLVM: %[[A_ARR:.*]] = load [4 x i32], ptr %{{.*}}, align 4
+// LLVM-NEXT: call void @func_single_array_element_struct_arg([4 x i32] %[[A_ARR]])
+
+// The argument is passed as its field, but the return stays the struct.
+cdwrap_t ret_cdwrap(cdwrap_t w) { return w; }
+
+// CIR: cir.func{{.*}} @ret_cdwrap(%[[ARG:.*]]: !cir.complex<!cir.double>) -> !rec_cdwrap_t
+// CIR-NEXT: %[[COERCE:.*]] = cir.alloca "coerce" align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+// CIR-NEXT: %[[FIELD:.*]] = cir.get_member %[[COERCE]][0] {name = ""} : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+// CIR-NEXT: cir.store %[[ARG]], %[[FIELD]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>, target_address_space(5)>
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+// CIR-NEXT: %[[W:.*]] = cir.alloca "w" align(8) init : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>
+// CIR-NEXT: %[[W_VIEW:.*]] = cir.cast address_space %[[W]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+// CIR-NEXT: %[[RETVAL_VIEW:.*]] = cir.cast address_space %[[RETVAL]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)> -> !cir.ptr<!rec_cdwrap_t>
+// CIR-NEXT: cir.copy %[[COERCE]] align(8) to %[[W_VIEW]] align(8) : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>, !cir.ptr<!rec_cdwrap_t>
+// CIR-NEXT: cir.copy %[[W_VIEW]] align(8) to %[[RETVAL_VIEW]] align(8) : !cir.ptr<!rec_cdwrap_t>
+// CIR-NEXT: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!rec_cdwrap_t, target_address_space(5)>, !rec_cdwrap_t
+// CIR-NEXT: cir.return %[[RET]] : !rec_cdwrap_t
+
+// LLVM: define dso_local %struct.cdwrap_t @ret_cdwrap({ double, double } %{{.*}})
More information about the cfe-commits
mailing list