[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