[clang] [llvm] [Clang][X86] Add Clang23Compat for __int128 bit-field ABI change (PR #220788)
Phoebe Wang via cfe-commits
cfe-commits at lists.llvm.org
Wed Sep 2 19:53:39 PDT 2026
https://github.com/phoebewang created https://github.com/llvm/llvm-project/pull/220788
Follow up of #216777.
Assisted-by: Claude Opus 4.8
>From e3bcbd8f24c3a64b83405f88bca4daa262597c9a Mon Sep 17 00:00:00 2001
From: Phoebe Wang <phoebe.wang at intel.com>
Date: Wed, 2 Sep 2026 19:48:59 -0700
Subject: [PATCH] [Clang][X86] Add Clang23Compat for __int128 bit-field ABI
change
Follow up of #216777.
Assisted-by: Claude Opus 4.8
---
clang/docs/ReleaseNotes.md | 3 +-
clang/include/clang/Basic/ABIVersions.def | 6 ++++
clang/lib/CodeGen/CodeGenModule.cpp | 1 +
clang/lib/CodeGen/Targets/X86.cpp | 16 +++++++---
.../X86/x86_64-unnamed-bitfield-abi-compat.c | 30 +++++++++++++++++++
llvm/include/llvm/ABI/TargetInfo.h | 3 +-
llvm/lib/ABI/Targets/X86.cpp | 10 +++++--
7 files changed, 60 insertions(+), 9 deletions(-)
create mode 100644 clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c
diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index bf295981710ac..17c10fd4ff86f 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -106,7 +106,8 @@ features cannot lower the translation-unit ABI level;
Aggregates where this changes the classification may be passed or returned
differently -- a struct holding a run of `__int128` bit-fields, for example,
now travels in the two integer registers the ABI assigns it. This also fixes
- a crash when such a struct was passed or returned. (#GH202205)
+ a crash when such a struct was passed or returned. `-fclang-abi-compat=23`
+ restores the previous behavior. (#GH202205)
### AST Dumping Potentially Breaking Changes
diff --git a/clang/include/clang/Basic/ABIVersions.def b/clang/include/clang/Basic/ABIVersions.def
index e1017a1547773..3c434da91bfab 100644
--- a/clang/include/clang/Basic/ABIVersions.def
+++ b/clang/include/clang/Basic/ABIVersions.def
@@ -161,6 +161,12 @@ ABI_VER_MAJOR(22)
/// - On MIPS N32/N64, always pass a `_Complex float` or `_Complex double`
/// argument as its two parts, one floating-point register each, instead of
/// packing it into integer registers once there is no room for both.
+/// - On x86-64 System V, skip every unnamed bit-field as padding when
+/// classifying an aggregate, instead of treating a non-zero-width unnamed
+/// bit-field as INTEGER storage like a named one the way GCC does. (This
+/// faithfully reproduces Clang 23, including its crash on aggregates such
+/// as a run of `__int128` bit-fields, where skipping the unnamed field
+/// leaves part of a wider access unit unclassified.)
ABI_VER_MAJOR(23)
/// Conform to the underlying platform's C and C++ ABIs as closely as we can.
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 17b5f0fe4133d..e0adfcc51c089 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -433,6 +433,7 @@ CodeGenModule::getLLVMABITargetInfo(llvm::abi::TypeBuilder &TB) {
Compat > LangOptions::ClangABI::Ver20 && !T.isPS();
CompatInfo.Clang11Compat =
Compat <= LangOptions::ClangABI::Ver11 || T.isPS();
+ CompatInfo.Clang23Compat = Compat <= LangOptions::ClangABI::Ver23;
bool Has64BitPointers = getTarget().getPointerWidth(LangAS::Default) == 64;
diff --git a/clang/lib/CodeGen/Targets/X86.cpp b/clang/lib/CodeGen/Targets/X86.cpp
index d60d71775a9d1..6a651e97902a3 100644
--- a/clang/lib/CodeGen/Targets/X86.cpp
+++ b/clang/lib/CodeGen/Targets/X86.cpp
@@ -2200,6 +2200,8 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, Class &Lo,
bool UseClang11Compat = getContext().getLangOpts().isCompatibleWith(
LangOptions::ClangABI::Ver11) ||
getContext().getTargetInfo().getTriple().isPS();
+ bool UseClang23Compat = getContext().getLangOpts().isCompatibleWith(
+ LangOptions::ClangABI::Ver23);
bool IsUnion = RT->isUnionType() && !UseClang11Compat;
for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
@@ -2207,9 +2209,14 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, Class &Lo,
uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
bool BitField = i->isBitField();
- // Ignore zero-length bit-fields. Other unnamed bit-fields are real
- // storage and classify like named ones, matching GCC.
- if (BitField && i->isZeroLengthBitField())
+ // Ignore padding bit-fields. Under -fclang-abi-compat=23 every unnamed
+ // bit-field is padding, faithfully reproducing Clang 23 (including its
+ // crash on aggregates where doing so leaves part of a wider access unit,
+ // e.g. an __int128 bit-field run, unclassified); otherwise only
+ // zero-length bit-fields are, and other unnamed bit-fields classify like
+ // named ones, matching GCC.
+ if (BitField && (UseClang23Compat ? i->isUnnamedBitField()
+ : i->isZeroLengthBitField()))
continue;
// AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger than
@@ -2250,7 +2257,8 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, Class &Lo,
// structure to be passed in memory even if unaligned, and
// therefore they can straddle an eightbyte.
if (BitField) {
- assert(!i->isZeroLengthBitField());
+ assert(UseClang23Compat ? !i->isUnnamedBitField()
+ : !i->isZeroLengthBitField());
uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
uint64_t Size = i->getBitWidthValue();
diff --git a/clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c b/clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c
new file mode 100644
index 0000000000000..31df6b7553585
--- /dev/null
+++ b/clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o - | \
+// RUN: FileCheck %s -check-prefix=NEW
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fclang-abi-compat=23 %s -o - | \
+// RUN: FileCheck %s -check-prefix=COMPAT
+
+// A non-zero-width unnamed bit-field classifies the eightbyte it occupies as
+// INTEGER like a named one, matching GCC, so this struct travels in two integer
+// registers. Under -fclang-abi-compat=23 the unnamed bit-field is padding, so
+// the low eightbyte stays NO_CLASS and only the high eightbyte is passed.
+struct s {
+ long : 64;
+ long a;
+};
+
+// NEW-LABEL: define{{.*}} { i64, i64 } @get()
+// COMPAT-LABEL: define{{.*}} i64 @get()
+struct s get(void) {
+ return (struct s){0};
+}
+
+// NEW-LABEL: define{{.*}} void @put(i64 %a.coerce0, i64 %a.coerce1)
+// COMPAT-LABEL: define{{.*}} void @put(i64 %a.coerce)
+void put(struct s a) {
+}
+
+// Note: -fclang-abi-compat=23 faithfully reproduces Clang 23, so it also
+// reproduces Clang 23's crash on a run of __int128 bit-fields (skipping the
+// unnamed field leaves half of the i128 access unit unclassified). That shape
+// is deliberately not exercised here; the corrected classification is covered
+// in x86_64-arguments.c.
diff --git a/llvm/include/llvm/ABI/TargetInfo.h b/llvm/include/llvm/ABI/TargetInfo.h
index 8132de140064a..1433c59623909 100644
--- a/llvm/include/llvm/ABI/TargetInfo.h
+++ b/llvm/include/llvm/ABI/TargetInfo.h
@@ -46,11 +46,12 @@ struct ABICompatInfo {
bool ClassifyIntegerMMXAsSSE : 1;
bool HonorsRevision98 : 1;
bool Clang11Compat : 1;
+ bool Clang23Compat : 1;
ABICompatInfo()
: PassInt128VectorsInMem(true), ReturnCXXRecordGreaterThan128InMem(true),
ClassifyIntegerMMXAsSSE(true), HonorsRevision98(true),
- Clang11Compat(true) {}
+ Clang11Compat(true), Clang23Compat(false) {}
/// Return flags matching the ABI emitted by the given Clang major version.
// TODO: fill in per-version flag overrides.
diff --git a/llvm/lib/ABI/Targets/X86.cpp b/llvm/lib/ABI/Targets/X86.cpp
index 88bfb8ad453cc..5bb69f55de2bd 100644
--- a/llvm/lib/ABI/Targets/X86.cpp
+++ b/llvm/lib/ABI/Targets/X86.cpp
@@ -557,9 +557,13 @@ void X86_64TargetInfo::classify(const Type *T, uint64_t OffsetBase, Class &Lo,
uint64_t Offset = OffsetBase + Field.OffsetInBits;
bool BitField = Field.IsBitField;
- // Ignore zero-length bit-fields. Other unnamed bit-fields are real
- // storage and classify like named ones, matching GCC.
- if (BitField && Field.BitFieldWidth == 0)
+ // Ignore padding bit-fields. Under Clang 23 compatibility every unnamed
+ // bit-field is padding, faithfully reproducing Clang 23; otherwise only
+ // zero-length bit-fields are, and other unnamed bit-fields classify like
+ // named ones, matching GCC.
+ if (BitField &&
+ (getABICompatInfo().Clang23Compat ? Field.IsUnnamedBitfield
+ : Field.BitFieldWidth == 0))
continue;
if (Size > 128 &&
More information about the cfe-commits
mailing list