[clang] [llvm] [LLVM][ABI][AARCH64] Add support for MSVC homogeneous aggregates (PR #239846)
Madhur Amilkanthwar via cfe-commits
cfe-commits at lists.llvm.org
Sun Nov 8 23:32:15 PST 2026
================
@@ -0,0 +1,145 @@
+// RUN: %clang_cc1 -triple aarch64-windows-msvc -std=c++20 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple aarch64-windows-msvc -std=c++20 -fexperimental-abi-lowering -emit-llvm -o - %s 2>&1 | FileCheck %s --implicit-check-not="not yet implemented"
+
+// Each record holds 16 bytes of doubles. An HFA is passed as [2 x double] and
+// a record that MSVC does not treat as an HFA is passed as [2 x i64].
+
+struct Empty {};
+struct ZeroLength {
+ int arr[0];
+};
+struct DoubleBase {
+ double a;
+};
+
+extern "C" {
+
+struct Pod {
+ double a, b;
+};
+void arg_pod(Pod s) {}
+// CHECK: define{{.*}} void @arg_pod([2 x double] %{{.*}})
+
+struct TrivialCopyAssign {
+ double a, b;
+ TrivialCopyAssign &operator=(const TrivialCopyAssign &) = default;
+};
+void arg_trivial_copy_assign(TrivialCopyAssign s) {}
+// CHECK: define{{.*}} void @arg_trivial_copy_assign([2 x double] %{{.*}})
+
+struct NonTrivialCopyAssign {
+ double a, b;
+ NonTrivialCopyAssign &operator=(const NonTrivialCopyAssign &);
+};
+void arg_non_trivial_copy_assign(NonTrivialCopyAssign s) {}
+// CHECK: define{{.*}} void @arg_non_trivial_copy_assign([2 x i64] %{{.*}})
+
+struct NonDefaultCtor {
+ double a, b;
+ NonDefaultCtor(int);
+};
+void arg_non_default_ctor(NonDefaultCtor s) {}
+// CHECK: define{{.*}} void @arg_non_default_ctor([2 x double] %{{.*}})
+
+struct UserDefaultCtor {
+ double a, b;
+ UserDefaultCtor();
+};
+void arg_user_default_ctor(UserDefaultCtor s) {}
+// CHECK: define{{.*}} void @arg_user_default_ctor([2 x i64] %{{.*}})
+
+struct MemberInit {
+ double a = 1.0;
+ double b;
+};
+void arg_member_init(MemberInit s) {}
+// CHECK: define{{.*}} void @arg_member_init([2 x i64] %{{.*}})
+
+struct TrivialDtor {
+ double a, b;
+ ~TrivialDtor() = default;
+};
+void arg_trivial_dtor(TrivialDtor s) {}
+// CHECK: define{{.*}} void @arg_trivial_dtor([2 x double] %{{.*}})
+
+struct NonTrivialDtor {
+ double a, b;
+ ~NonTrivialDtor();
+};
+void arg_non_trivial_dtor(NonTrivialDtor s) {}
+// CHECK: define{{.*}} void @arg_non_trivial_dtor([2 x i64] %{{.*}})
+
+struct PrivateMember {
+ double a;
+
+private:
+ double b;
+};
+void arg_private_member(PrivateMember s) {}
+// CHECK: define{{.*}} void @arg_private_member([2 x double] %{{.*}})
+
+// A non-empty base contributes members, but an empty base disqualifies the
+// derived record.
+struct NonEmptyBase : DoubleBase {
+ double b;
+};
+void arg_non_empty_base(NonEmptyBase s) {}
+// CHECK: define{{.*}} void @arg_non_empty_base([2 x double] %{{.*}})
+
+struct EmptyBase : Empty {
+ double a, b;
+};
+void arg_empty_base(EmptyBase s) {}
+// CHECK: define{{.*}} void @arg_empty_base([2 x i64] %{{.*}})
+
+struct IndirectEmptyBase : EmptyBase {};
+void arg_indirect_empty_base(IndirectEmptyBase s) {}
+// CHECK: define{{.*}} void @arg_indirect_empty_base([2 x i64] %{{.*}})
+
+// The rules also apply to the record type of each field, including array
+// elements and union members.
+struct PodField {
+ Pod p;
+};
+void arg_pod_field(PodField s) {}
+// CHECK: define{{.*}} void @arg_pod_field([2 x double] %{{.*}})
+
+struct EmptyBaseField {
+ EmptyBase e;
+};
+void arg_empty_base_field(EmptyBaseField s) {}
+// CHECK: define{{.*}} void @arg_empty_base_field([2 x i64] %{{.*}})
+
+struct EmptyBaseArrayField {
+ EmptyBase e[1];
+};
+void arg_empty_base_array_field(EmptyBaseArrayField s) {}
+// CHECK: define{{.*}} void @arg_empty_base_array_field([2 x i64] %{{.*}})
----------------
madhur13490 wrote:
Could you add an empty field that takes no space? Neither path checks fields here; both rely on the padding check to reject empty fields (the comment in `MicrosoftCXXABI::isPermittedToBeHomogeneousAggregate` says as much). With `[[msvc::no_unique_address]]` there is no padding, so both paths treat the record as an HFA:
```cpp
struct NoUniqueAddressEmpty {
[[msvc::no_unique_address]] Empty e;
double a, b;
};
void arg_no_unique_address_empty(NoUniqueAddressEmpty s) {}
// CHECK: define{{.*}} void @arg_no_unique_address_empty([2 x double] %{{.*}})
```
Having this under both RUN lines would catch either path changing how it handles this case.
https://github.com/llvm/llvm-project/pull/239846
More information about the cfe-commits
mailing list