[clang] [llvm] [LLVM][ABI][AARCH64] Add support for MSVC homogeneous aggregates (PR #239846)

Andy Kaylor via cfe-commits cfe-commits at lists.llvm.org
Fri Nov 6 16:04:36 PST 2026


https://github.com/andykaylor created https://github.com/llvm/llvm-project/pull/239846

This adds classification support for homogeneous aggregates on AArch64 when the MSVC CXXABI is in use. The MSVC CXABI has its own set of rules that may exclude some types that are otherwise recognized as homogeneous aggregates for AArch64 targets. The rules are applied exactly as they are in Clang's MicrosoftCXXABI::isPermittedToBeHomogeneousAggregate without any attempt to determine whether the type is also excluded by some other AArch64 rule.

Assisted-by: Cursor / claude-opus-5.5

>From 9d5c5b66dd0d7df3d171e67901be3acce2e58d49 Mon Sep 17 00:00:00 2001
From: Andy Kaylor <akaylor at nvidia.com>
Date: Fri, 6 Nov 2026 14:57:06 -0800
Subject: [PATCH] [LLVM][ABI][AARCH64] Add support for MSVC homogeneous
 aggregates

This adds classification support for homogeneous aggregates on AArch64 when
the MSVC CXXABI is in use. The MSVC CXABI has its own set of rules that may
exclude some types that are otherwise recognized as homogeneous aggregates
for AArch64 targets. The rules are applied exactly as they are in Clang's
MicrosoftCXXABI::isPermittedToBeHomogeneousAggregate without any attempt to
determine whether the type is also excluded by some other AArch64 rule.

Assisted-by: Cursor / claude-opus-5.5
---
 clang/lib/CodeGen/QualTypeMapper.cpp          |  29 +++-
 .../CodeGen/AArch64/abi-classify-msvc-hfa.cpp | 145 ++++++++++++++++++
 llvm/include/llvm/ABI/Types.h                 |  25 ++-
 llvm/lib/ABI/Targets/AArch64.cpp              |  25 ++-
 llvm/unittests/ABI/AArch64TargetInfoTest.cpp  |  89 +++++++++++
 5 files changed, 297 insertions(+), 16 deletions(-)
 create mode 100644 clang/test/CodeGen/AArch64/abi-classify-msvc-hfa.cpp

diff --git a/clang/lib/CodeGen/QualTypeMapper.cpp b/clang/lib/CodeGen/QualTypeMapper.cpp
index e8002b2b08cab4..3531ec2ba0812d 100644
--- a/clang/lib/CodeGen/QualTypeMapper.cpp
+++ b/clang/lib/CodeGen/QualTypeMapper.cpp
@@ -445,6 +445,22 @@ QualTypeMapper::convertMemberPointerType(const clang::MemberPointerType *MPT) {
   return Builder.getMemberPointerType(IsFunctionPointer, Size, Align);
 }
 
+/// Returns the record flags that describe C++ class properties of \p RD.
+static llvm::abi::RecordFlags getCXXRecordFlags(const CXXRecordDecl *RD) {
+  llvm::abi::RecordFlags RecFlags = llvm::abi::RecordFlags::IsCXXRecord;
+  if (RD->isPolymorphic())
+    RecFlags |= llvm::abi::RecordFlags::IsPolymorphic;
+  if (RD->isEmpty())
+    RecFlags |= llvm::abi::RecordFlags::IsCXXEmpty;
+  if (RD->hasNonTrivialCopyAssignment())
+    RecFlags |= llvm::abi::RecordFlags::HasNonTrivialCopyAssignment;
+  if (RD->hasNonTrivialDestructor())
+    RecFlags |= llvm::abi::RecordFlags::HasNonTrivialDestructor;
+  if (RD->hasNonTrivialDefaultConstructor())
+    RecFlags |= llvm::abi::RecordFlags::HasNonTrivialDefaultConstructor;
+  return RecFlags;
+}
+
 /// Converts record types (struct/class/union) to LLVM ABI representations.
 /// This is the main dispatch method that handles different record kinds
 /// and delegates to specialized converters.
@@ -525,9 +541,7 @@ QualTypeMapper::convertCXXRecordType(const CXXRecordDecl *RD) {
   llvm::Align UnadjustedAlign =
       llvm::Align(Layout.getUnadjustedAlignment().getQuantity());
 
-  llvm::abi::RecordFlags RecFlags = llvm::abi::RecordFlags::IsCXXRecord;
-  if (RD->isPolymorphic())
-    RecFlags |= llvm::abi::RecordFlags::IsPolymorphic;
+  llvm::abi::RecordFlags RecFlags = getCXXRecordFlags(RD);
   if (RD->canPassInRegisters())
     RecFlags |= llvm::abi::RecordFlags::CanPassInRegisters;
   if (RD->hasFlexibleArrayMember())
@@ -565,7 +579,6 @@ const llvm::abi::RecordType *
 QualTypeMapper::convertStructType(const clang::RecordDecl *RD) {
   const ASTRecordLayout &Layout = ASTCtx.getASTRecordLayout(RD);
 
-  bool IsCXXRecord = isa<CXXRecordDecl>(RD);
   SmallVector<llvm::abi::FieldInfo, 16> Fields;
   computeFieldInfo(RD, Fields, Layout);
 
@@ -576,8 +589,8 @@ QualTypeMapper::convertStructType(const clang::RecordDecl *RD) {
       llvm::Align(Layout.getUnadjustedAlignment().getQuantity());
 
   llvm::abi::RecordFlags RecFlags = llvm::abi::RecordFlags::None;
-  if (IsCXXRecord)
-    RecFlags |= llvm::abi::RecordFlags::IsCXXRecord;
+  if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
+    RecFlags |= getCXXRecordFlags(CXXRD);
   if (RD->canPassInRegisters())
     RecFlags |= llvm::abi::RecordFlags::CanPassInRegisters;
   if (RD->hasFlexibleArrayMember())
@@ -612,8 +625,8 @@ QualTypeMapper::convertUnionType(const clang::RecordDecl *RD) {
     RecFlags |= llvm::abi::RecordFlags::IsTransparent;
   if (RD->canPassInRegisters())
     RecFlags |= llvm::abi::RecordFlags::CanPassInRegisters;
-  if (isa<CXXRecordDecl>(RD))
-    RecFlags |= llvm::abi::RecordFlags::IsCXXRecord;
+  if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
+    RecFlags |= getCXXRecordFlags(CXXRD);
 
   return Builder.getUnionType(AllFields, Size, Alignment, UnadjustedAlign,
                               llvm::abi::StructPacking::Default, RecFlags);
diff --git a/clang/test/CodeGen/AArch64/abi-classify-msvc-hfa.cpp b/clang/test/CodeGen/AArch64/abi-classify-msvc-hfa.cpp
new file mode 100644
index 00000000000000..6be8d8ebb63962
--- /dev/null
+++ b/clang/test/CodeGen/AArch64/abi-classify-msvc-hfa.cpp
@@ -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] %{{.*}})
+
+union EmptyBaseUnionMember {
+  EmptyBase e;
+};
+void arg_empty_base_union_member(EmptyBaseUnionMember s) {}
+// CHECK: define{{.*}} void @arg_empty_base_union_member([2 x i64] %{{.*}})
+
+// A record whose only member is a zero-length array is not empty in the
+// std::is_empty sense, so it does not disqualify a derived record.
+struct ZeroLengthBase : ZeroLength {
+  double a, b;
+};
+void arg_zero_length_base(ZeroLengthBase s) {}
+// CHECK: define{{.*}} void @arg_zero_length_base([2 x double] %{{.*}})
+
+union DoubleUnion {
+  double a[2];
+};
+void arg_double_union(DoubleUnion s) {}
+// CHECK: define{{.*}} void @arg_double_union([2 x double] %{{.*}})
+
+union NonTrivialDefaultCtorUnion {
+  double a[2] = {1.0, 2.0};
+};
+void arg_non_trivial_default_ctor_union(NonTrivialDefaultCtorUnion s) {}
+// CHECK: define{{.*}} void @arg_non_trivial_default_ctor_union([2 x i64] %{{.*}})
+
+}
diff --git a/llvm/include/llvm/ABI/Types.h b/llvm/include/llvm/ABI/Types.h
index 34e733f5ed630a..f0713312335f9b 100644
--- a/llvm/include/llvm/ABI/Types.h
+++ b/llvm/include/llvm/ABI/Types.h
@@ -413,7 +413,12 @@ enum RecordFlags : unsigned {
   IsCXXRecord = 1 << 3,
   IsPolymorphic = 1 << 4,
   HasFlexibleArrayMember = 1 << 5,
-  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ HasFlexibleArrayMember),
+  IsCXXEmpty = 1 << 6,
+  HasNonTrivialCopyAssignment = 1 << 7,
+  HasNonTrivialDestructor = 1 << 8,
+  HasNonTrivialDefaultConstructor = 1 << 9,
+  LLVM_MARK_AS_BITMASK_ENUM(
+      /* LargestValue = */ HasNonTrivialDefaultConstructor),
 };
 
 class RecordType : public Type {
@@ -451,6 +456,24 @@ class RecordType : public Type {
     return static_cast<unsigned>(Flags & RecordFlags::HasFlexibleArrayMember) !=
            0;
   }
+  /// True for a C++ class that is empty in the sense of std::is_empty. This
+  /// differs from isEmpty(), which applies the ABI rules for ignoring empty
+  /// records.
+  bool isCXXEmpty() const {
+    return static_cast<unsigned>(Flags & RecordFlags::IsCXXEmpty) != 0;
+  }
+  bool hasNonTrivialCopyAssignment() const {
+    return static_cast<unsigned>(Flags &
+                                 RecordFlags::HasNonTrivialCopyAssignment) != 0;
+  }
+  bool hasNonTrivialDestructor() const {
+    return static_cast<unsigned>(Flags &
+                                 RecordFlags::HasNonTrivialDestructor) != 0;
+  }
+  bool hasNonTrivialDefaultConstructor() const {
+    return static_cast<unsigned>(
+               Flags & RecordFlags::HasNonTrivialDefaultConstructor) != 0;
+  }
   uint32_t getNumBaseClasses() const { return BaseClasses.size(); }
   uint32_t getNumVirtualBaseClasses() const {
     return VirtualBaseClasses.size();
diff --git a/llvm/lib/ABI/Targets/AArch64.cpp b/llvm/lib/ABI/Targets/AArch64.cpp
index c49b66a76511ea..4f47e7f9de014c 100644
--- a/llvm/lib/ABI/Targets/AArch64.cpp
+++ b/llvm/lib/ABI/Targets/AArch64.cpp
@@ -683,15 +683,26 @@ bool AArch64TargetInfo::isZeroLengthBitfieldPermittedInHomogeneousAggregate()
   return true;
 }
 
-bool AArch64TargetInfo::isPermittedToBeHomogeneousAggregate(
-    const RecordType *RT) const {
-  if (Opts.IsMicrosoftCXXABI && RT->isCXXRecord()) {
-    // This won't always return false, but we don't have enough information to
-    // perform the full check correctly yet.
-    reportNYI("MicrosoftCXXABI homogeneous record classification");
+// MSVC on Windows on Arm64 excludes some C++ records from being HFAs that
+// AAPCS64 would otherwise permit. These are the rules observed from MSVC.
+static bool isMSVCPermittedHomogeneousAggregate(const RecordType *RT) {
+  if (RT->isCXXEmpty() || RT->isPolymorphic() ||
+      RT->hasNonTrivialCopyAssignment() || RT->hasNonTrivialDestructor() ||
+      RT->hasNonTrivialDefaultConstructor())
     return false;
-  }
 
+  auto IsPermittedBase = [](const FieldInfo &Base) {
+    const auto *BaseRT = dyn_cast<RecordType>(Base.FieldType);
+    return !BaseRT || isMSVCPermittedHomogeneousAggregate(BaseRT);
+  };
+  return all_of(RT->getBaseClasses(), IsPermittedBase) &&
+         all_of(RT->getVirtualBaseClasses(), IsPermittedBase);
+}
+
+bool AArch64TargetInfo::isPermittedToBeHomogeneousAggregate(
+    const RecordType *RT) const {
+  if (Opts.IsMicrosoftCXXABI && RT->isCXXRecord())
+    return isMSVCPermittedHomogeneousAggregate(RT);
   return true;
 }
 
diff --git a/llvm/unittests/ABI/AArch64TargetInfoTest.cpp b/llvm/unittests/ABI/AArch64TargetInfoTest.cpp
index 2c7920272332bb..69cd9eafd81efc 100644
--- a/llvm/unittests/ABI/AArch64TargetInfoTest.cpp
+++ b/llvm/unittests/ABI/AArch64TargetInfoTest.cpp
@@ -2071,4 +2071,93 @@ TEST_F(AArch64TargetInfoTest, ClassifyReturnSmallAggregate) {
   expectDirectCoercedInteger(FI->getReturnInfo(), 8);
 }
 
+// Under the Microsoft C++ ABI, a C++ record is not an HFA if it is empty, is
+// polymorphic, has a non-trivial copy assignment operator, destructor, or
+// default constructor, or has a base class that fails any of these checks.
+// A record rejected as an HFA is passed as a 16-byte aggregate in a pair of
+// i64. Without the Microsoft C++ ABI, and for C records, every case is an HFA.
+TEST_F(AArch64TargetInfoTest, ClassifyArgumentMicrosoftCXXHFA) {
+  auto CXXFlags = [](RecordFlags Extra) {
+    return static_cast<RecordFlags>(RecordFlags::CanPassInRegisters |
+                                    RecordFlags::IsCXXRecord | Extra);
+  };
+  const FieldInfo TwoDoubles[] = {FieldInfo(F64, 0), FieldInfo(F64, 64)};
+  auto MakeTwoDoubles = [&](RecordFlags Flags,
+                            llvm::ArrayRef<FieldInfo> Bases = {}) {
+    return makeRecord(TwoDoubles, 128, llvm::Align(8),
+                      /*UnadjustedAlign=*/llvm::Align(8), Flags, Bases);
+  };
+
+  const ABIType *CRecord = MakeTwoDoubles(RecordFlags::CanPassInRegisters);
+  const ABIType *Pod = MakeTwoDoubles(CXXFlags(RecordFlags::None));
+  const ABIType *Polymorphic =
+      MakeTwoDoubles(CXXFlags(RecordFlags::IsPolymorphic));
+  const ABIType *NonTrivialCopyAssign =
+      MakeTwoDoubles(CXXFlags(RecordFlags::HasNonTrivialCopyAssignment));
+  const ABIType *NonTrivialDtor =
+      MakeTwoDoubles(CXXFlags(RecordFlags::HasNonTrivialDestructor));
+  const ABIType *NonTrivialDefaultCtor =
+      MakeTwoDoubles(CXXFlags(RecordFlags::HasNonTrivialDefaultConstructor));
+
+  // struct Empty {};
+  // struct EmptyBase : Empty { double a, b; };
+  // struct IndirectEmptyBase : EmptyBase {};
+  const ABIType *Empty =
+      makeRecord({}, 8, llvm::Align(1), /*UnadjustedAlign=*/llvm::Align(1),
+                 CXXFlags(RecordFlags::IsCXXEmpty));
+  const ABIType *EmptyBase =
+      MakeTwoDoubles(CXXFlags(RecordFlags::None), {FieldInfo(Empty, 0)});
+  const ABIType *IndirectEmptyBase =
+      makeRecord({}, 128, llvm::Align(8), /*UnadjustedAlign=*/llvm::Align(8),
+                 CXXFlags(RecordFlags::None), {FieldInfo(EmptyBase, 0)});
+
+  // struct ZeroLength { int arr[0]; };
+  // struct ZeroLengthBase : ZeroLength { double a, b; };
+  // ZeroLength is an empty record for the ABI but not for std::is_empty, so
+  // it does not disqualify the derived record.
+  const ABIType *ZeroLength =
+      makeRecord({FieldInfo(TB.getArrayType(I32, 0, /*SizeInBits=*/0), 0)}, 0,
+                 llvm::Align(4), /*UnadjustedAlign=*/llvm::Align(4),
+                 CXXFlags(RecordFlags::None));
+  const ABIType *ZeroLengthBase =
+      MakeTwoDoubles(CXXFlags(RecordFlags::None), {FieldInfo(ZeroLength, 0)});
+
+  // struct DoubleBase { double a; };
+  // struct NonEmptyBase : DoubleBase { double b; };
+  const ABIType *DoubleBase = makeRecord(
+      {FieldInfo(F64, 0)}, 64, llvm::Align(8),
+      /*UnadjustedAlign=*/llvm::Align(8), CXXFlags(RecordFlags::None));
+  const ABIType *NonEmptyBase =
+      makeRecord({FieldInfo(F64, 64)}, 128, llvm::Align(8),
+                 /*UnadjustedAlign=*/llvm::Align(8),
+                 CXXFlags(RecordFlags::None), {FieldInfo(DoubleBase, 0)});
+
+  const ABIType *HFAs[] = {CRecord, Pod, ZeroLengthBase, NonEmptyBase};
+  const ABIType *MSVCNonHFAs[] = {Polymorphic,    NonTrivialCopyAssign,
+                                  NonTrivialDtor, NonTrivialDefaultCtor,
+                                  EmptyBase,      IndirectEmptyBase};
+
+  auto Classify = [&](const ABIType *Ty, bool IsMicrosoftCXXABI) {
+    AArch64ABIOptions Opts(AArch64ABIKind::Win64);
+    Opts.IsCXX = true;
+    Opts.IsMicrosoftCXXABI = IsMicrosoftCXXABI;
+    std::unique_ptr<TargetInfo> TI = createAArch64TargetInfo(TB, Opts);
+    std::unique_ptr<FunctionInfo> FI =
+        FunctionInfo::create(llvm::CallingConv::C, Void, {Ty});
+    TI->computeInfo(*FI);
+    return FI->getArgInfo(0).Info;
+  };
+
+  for (bool IsMicrosoftCXXABI : {false, true})
+    for (const ABIType *Ty : HFAs)
+      expectHFADirectArg(Classify(Ty, IsMicrosoftCXXABI), F64, 2,
+                         /*DirectAlign=*/std::nullopt);
+
+  for (const ABIType *Ty : MSVCNonHFAs) {
+    expectHFADirectArg(Classify(Ty, /*IsMicrosoftCXXABI=*/false), F64, 2,
+                       /*DirectAlign=*/std::nullopt);
+    expectDirectI64Pair(Classify(Ty, /*IsMicrosoftCXXABI=*/true));
+  }
+}
+
 } // namespace



More information about the cfe-commits mailing list