https://github.com/phoebewang updated https://github.com/llvm/llvm-project/pull/220788
>From e3bcbd8f24c3a64b83405f88bca4daa262597c9a Mon Sep 17 00:00:00 2001 From: Phoebe Wang <[email protected]> Date: Wed, 2 Sep 2026 19:48:59 -0700 Subject: [PATCH 1/5] [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 && >From 87ea3206955f0c0e14782725a8167e5cc21bd13a Mon Sep 17 00:00:00 2001 From: Phoebe Wang <[email protected]> Date: Fri, 4 Sep 2026 03:15:41 -0700 Subject: [PATCH 2/5] Change Clang23Compat to ClassifyUnnamedBitFields --- clang/lib/CodeGen/CodeGenModule.cpp | 2 +- clang/lib/CodeGen/Targets/X86.cpp | 23 +++++++++++------------ llvm/include/llvm/ABI/TargetInfo.h | 4 ++-- llvm/lib/ABI/Targets/X86.cpp | 13 ++++++------- 4 files changed, 20 insertions(+), 22 deletions(-) diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index e0adfcc51c089..a570cf5c4c7d0 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -433,7 +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; + CompatInfo.ClassifyUnnamedBitFields = 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 6a651e97902a3..477fdaf7562e7 100644 --- a/clang/lib/CodeGen/Targets/X86.cpp +++ b/clang/lib/CodeGen/Targets/X86.cpp @@ -2200,8 +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 ClassifyUnnamedBitFields = getContext().getLangOpts().getClangABICompat() > + LangOptions::ClangABI::Ver23; bool IsUnion = RT->isUnionType() && !UseClang11Compat; for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); @@ -2209,14 +2209,13 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, Class &Lo, uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx); bool BitField = i->isBitField(); - // 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())) + // Ignore padding bit-fields. Normally only zero-length bit-fields are + // padding, but under -fclang-abi-compat=23 every unnamed bit-field is, + // faithfully reproducing Clang 23 -- including its crash on aggregates + // where skipping one leaves part of a wider access unit (e.g. an + // __int128 bit-field run) unclassified. + if (BitField && (ClassifyUnnamedBitFields ? i->isZeroLengthBitField() + : i->isUnnamedBitField())) continue; // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger than @@ -2257,8 +2256,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(UseClang23Compat ? !i->isUnnamedBitField() - : !i->isZeroLengthBitField()); + assert(ClassifyUnnamedBitFields ? !i->isZeroLengthBitField() + : !i->isUnnamedBitField()); uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx); uint64_t Size = i->getBitWidthValue(); diff --git a/llvm/include/llvm/ABI/TargetInfo.h b/llvm/include/llvm/ABI/TargetInfo.h index 1433c59623909..ea621597e5b22 100644 --- a/llvm/include/llvm/ABI/TargetInfo.h +++ b/llvm/include/llvm/ABI/TargetInfo.h @@ -46,12 +46,12 @@ struct ABICompatInfo { bool ClassifyIntegerMMXAsSSE : 1; bool HonorsRevision98 : 1; bool Clang11Compat : 1; - bool Clang23Compat : 1; + bool ClassifyUnnamedBitFields : 1; ABICompatInfo() : PassInt128VectorsInMem(true), ReturnCXXRecordGreaterThan128InMem(true), ClassifyIntegerMMXAsSSE(true), HonorsRevision98(true), - Clang11Compat(true), Clang23Compat(false) {} + Clang11Compat(true), ClassifyUnnamedBitFields(true) {} /// 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 5bb69f55de2bd..fd7a5e15b3548 100644 --- a/llvm/lib/ABI/Targets/X86.cpp +++ b/llvm/lib/ABI/Targets/X86.cpp @@ -557,13 +557,12 @@ void X86_64TargetInfo::classify(const Type *T, uint64_t OffsetBase, Class &Lo, uint64_t Offset = OffsetBase + Field.OffsetInBits; bool BitField = Field.IsBitField; - // 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)) + // Ignore padding bit-fields. Normally only zero-length bit-fields are + // padding, but under Clang 23 compatibility every unnamed bit-field is, + // faithfully reproducing Clang 23. + if (BitField && (getABICompatInfo().ClassifyUnnamedBitFields + ? Field.BitFieldWidth == 0 + : Field.IsUnnamedBitfield)) continue; if (Size > 128 && >From 1a53bf588ba62302cc9577b19111e3d30682b040 Mon Sep 17 00:00:00 2001 From: Phoebe Wang <[email protected]> Date: Fri, 4 Sep 2026 03:21:59 -0700 Subject: [PATCH 3/5] clang-format --- clang/lib/CodeGen/Targets/X86.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/clang/lib/CodeGen/Targets/X86.cpp b/clang/lib/CodeGen/Targets/X86.cpp index 477fdaf7562e7..098018075c57a 100644 --- a/clang/lib/CodeGen/Targets/X86.cpp +++ b/clang/lib/CodeGen/Targets/X86.cpp @@ -2200,8 +2200,9 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, Class &Lo, bool UseClang11Compat = getContext().getLangOpts().isCompatibleWith( LangOptions::ClangABI::Ver11) || getContext().getTargetInfo().getTriple().isPS(); - bool ClassifyUnnamedBitFields = getContext().getLangOpts().getClangABICompat() > - LangOptions::ClangABI::Ver23; + bool ClassifyUnnamedBitFields = + getContext().getLangOpts().getClangABICompat() > + LangOptions::ClangABI::Ver23; bool IsUnion = RT->isUnionType() && !UseClang11Compat; for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); >From b1ef8c4b531ff1a84695a8f3c43b47950e3e7f8e Mon Sep 17 00:00:00 2001 From: Phoebe Wang <[email protected]> Date: Sat, 5 Sep 2026 05:13:13 -0700 Subject: [PATCH 4/5] Back out for PlayStation --- clang/docs/ReleaseNotes.md | 14 +++++++------- clang/lib/CodeGen/CodeGenModule.cpp | 3 ++- clang/lib/CodeGen/Targets/X86.cpp | 3 ++- .../X86/x86_64-unnamed-bitfield-abi-compat.c | 7 +++++-- 4 files changed, 16 insertions(+), 11 deletions(-) diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md index 17c10fd4ff86f..a56c1df9b4103 100644 --- a/clang/docs/ReleaseNotes.md +++ b/clang/docs/ReleaseNotes.md @@ -101,13 +101,13 @@ features cannot lower the translation-unit ABI level; - On MIPS N32/N64, an `__int128` now correctly start in an even-numbered register or 16-byte aligned stack slot, matching GCC. -- On x86-64 System V, a non-zero-width unnamed bit-field now classifies the - eightbytes it occupies as INTEGER, like a named bit-field, matching GCC. - 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. `-fclang-abi-compat=23` - restores the previous behavior. (#GH202205) +- Except on PlayStation, on x86-64 System V a non-zero-width unnamed bit-field + now classifies the eightbytes it occupies as INTEGER, like a named bit-field, + matching GCC. 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. + `-fclang-abi-compat=23` restores the previous behavior. (#GH202205) ### AST Dumping Potentially Breaking Changes diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index a570cf5c4c7d0..eac082b03c907 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -433,7 +433,8 @@ CodeGenModule::getLLVMABITargetInfo(llvm::abi::TypeBuilder &TB) { Compat > LangOptions::ClangABI::Ver20 && !T.isPS(); CompatInfo.Clang11Compat = Compat <= LangOptions::ClangABI::Ver11 || T.isPS(); - CompatInfo.ClassifyUnnamedBitFields = Compat > LangOptions::ClangABI::Ver23; + CompatInfo.ClassifyUnnamedBitFields = + Compat > LangOptions::ClangABI::Ver23 && !T.isPS(); bool Has64BitPointers = getTarget().getPointerWidth(LangAS::Default) == 64; diff --git a/clang/lib/CodeGen/Targets/X86.cpp b/clang/lib/CodeGen/Targets/X86.cpp index 098018075c57a..f5d64e8ec0c1d 100644 --- a/clang/lib/CodeGen/Targets/X86.cpp +++ b/clang/lib/CodeGen/Targets/X86.cpp @@ -2202,7 +2202,8 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, Class &Lo, getContext().getTargetInfo().getTriple().isPS(); bool ClassifyUnnamedBitFields = getContext().getLangOpts().getClangABICompat() > - LangOptions::ClangABI::Ver23; + LangOptions::ClangABI::Ver23 && + !getContext().getTargetInfo().getTriple().isPS(); bool IsUnion = RT->isUnionType() && !UseClang11Compat; for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 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 index 31df6b7553585..c47b465a62c89 100644 --- a/clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c +++ b/clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c @@ -2,11 +2,14 @@ // 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 +// RUN: %clang_cc1 -triple x86_64-scei-ps4 -emit-llvm %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. +// registers. Under -fclang-abi-compat=23 (and on PlayStation) 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; >From 2e6aad3761b081a6159575b85fd00cc9f0e17edf Mon Sep 17 00:00:00 2001 From: Phoebe Wang <[email protected]> Date: Sat, 5 Sep 2026 19:54:00 -0700 Subject: [PATCH 5/5] Add PS5 triple --- clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c | 2 ++ 1 file changed, 2 insertions(+) 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 index c47b465a62c89..b4b5e7ee30240 100644 --- a/clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c +++ b/clang/test/CodeGen/X86/x86_64-unnamed-bitfield-abi-compat.c @@ -4,6 +4,8 @@ // RUN: FileCheck %s -check-prefix=COMPAT // RUN: %clang_cc1 -triple x86_64-scei-ps4 -emit-llvm %s -o - | \ // RUN: FileCheck %s -check-prefix=COMPAT +// RUN: %clang_cc1 -triple x86_64-scei-ps5 -emit-llvm %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 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
