maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Layout/ms-x86-pack-and-align.cpp

810 lines
26 KiB
C++
Raw Normal View History

__declspec is not a core Clang language extension. Instead, require -fms-extensions or -fborland to enable the language extension. Note: __declspec is also temporarily enabled when compiling for a CUDA target because there are implementation details relying on __declspec(property) support currently. When those details change, __declspec should be disabled for CUDA targets. llvm-svn: 238238
2015-05-27 03:44:52 +08:00
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only -Wno-inaccessible-base %s 2>&1 \
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
// RUN: | FileCheck %s
__declspec is not a core Clang language extension. Instead, require -fms-extensions or -fborland to enable the language extension. Note: __declspec is also temporarily enabled when compiling for a CUDA target because there are implementation details relying on __declspec(property) support currently. When those details change, __declspec should be disabled for CUDA targets. llvm-svn: 238238
2015-05-27 03:44:52 +08:00
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only -Wno-inaccessible-base %s 2>/dev/null \
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
// RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...);
char buffer[419430400];
struct A {
char a;
A() {
printf("A = %d\n", (int)((char*)this - buffer));
printf("A.a = %d\n", (int)((char*)&a - buffer));
}
};
struct B {
__declspec(align(4)) long long a;
B() {
printf("B = %d\n", (int)((char*)this - buffer));
printf("B.a = %d\n", (int)((char*)&a - buffer));
}
};
#pragma pack(push, 2)
struct X {
B a;
char b;
int c;
X() {
printf("X = %d\n", (int)((char*)this - buffer));
printf("X.a = %d\n", (int)((char*)&a - buffer));
printf("X.b = %d\n", (int)((char*)&b - buffer));
printf("X.c = %d\n", (int)((char*)&c - buffer));
}
};
// CHECK: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct X
// CHECK-NEXT: 0 | struct B a
// CHECK-NEXT: 0 | long long a
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: 8 | char b
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-NEXT: 10 | int c
// CHECK-NEXT: | [sizeof=16, align=4
[ms-abi] Reordering __declspec(align) pragma pack handling This patch moves the check for pragma pack until after the application of __declspec align to before pragma pack. This causes observable changes in the use of tail padding for bases. A test case is included. llvm-svn: 199154
2014-01-14 06:25:55 +08:00
// CHECK-NEXT: | nvsize=14, nvalign=4]
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-X64: *** Dumping AST Record Layout
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
// CHECK-X64: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-X64-NEXT: 0 | struct X
// CHECK-X64-NEXT: 0 | struct B a
// CHECK-X64-NEXT: 0 | long long a
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: 8 | char b
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-X64-NEXT: 10 | int c
// CHECK-X64-NEXT: | [sizeof=16, align=4
[ms-abi] Reordering __declspec(align) pragma pack handling This patch moves the check for pragma pack until after the application of __declspec align to before pragma pack. This causes observable changes in the use of tail padding for bases. A test case is included. llvm-svn: 199154
2014-01-14 06:25:55 +08:00
// CHECK-X64-NEXT: | nvsize=14, nvalign=4]
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
struct Y : A, B {
char a;
int b;
Y() {
printf("Y = %d\n", (int)((char*)this - buffer));
printf("Y.a = %d\n", (int)((char*)&a - buffer));
printf("Y.b = %d\n", (int)((char*)&b - buffer));
}
};
// CHECK: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct Y
// CHECK-NEXT: 0 | struct A (base)
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 4 | struct B (base)
// CHECK-NEXT: 4 | long long a
// CHECK-NEXT: 12 | char a
// CHECK-NEXT: 14 | int b
// CHECK-NEXT: | [sizeof=20, align=4
[ms-abi] Change the way alignment is tracked This patch more cleanly seperates the concepts of Preferred Alignment and Required Alignment. Most notable that changes to Required Alignment do *not* impact preferred alignment until late in struct layout. This is observable when using pragma pack and non-virtual bases and the use of tail padding when laying them out. Test cases included. llvm-svn: 198988
2014-01-11 09:16:40 +08:00
// CHECK-NEXT: | nvsize=18, nvalign=4]
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
// CHECK-X64: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct Y
// CHECK-X64-NEXT: 0 | struct A (base)
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 4 | struct B (base)
// CHECK-X64-NEXT: 4 | long long a
// CHECK-X64-NEXT: 12 | char a
// CHECK-X64-NEXT: 14 | int b
// CHECK-X64-NEXT: | [sizeof=20, align=4
[ms-abi] Change the way alignment is tracked This patch more cleanly seperates the concepts of Preferred Alignment and Required Alignment. Most notable that changes to Required Alignment do *not* impact preferred alignment until late in struct layout. This is observable when using pragma pack and non-virtual bases and the use of tail padding when laying them out. Test cases included. llvm-svn: 198988
2014-01-11 09:16:40 +08:00
// CHECK-X64-NEXT: | nvsize=18, nvalign=4]
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
struct Z : virtual B {
char a;
int b;
Z() {
printf("Z = %d\n", (int)((char*)this - buffer));
printf("Z.a = %d\n", (int)((char*)&a - buffer));
printf("Z.b = %d\n", (int)((char*)&b - buffer));
}
};
// CHECK: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-NEXT: 0 | struct Z
// CHECK-NEXT: 0 | (Z vbtable pointer)
// CHECK-NEXT: 4 | char a
// CHECK-NEXT: 6 | int b
// CHECK-NEXT: 12 | struct B (virtual base)
// CHECK-NEXT: 12 | long long a
// CHECK-NEXT: | [sizeof=20, align=4
// CHECK-NEXT: | nvsize=10, nvalign=4]
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
// CHECK-X64: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-X64-NEXT: 0 | struct Z
// CHECK-X64-NEXT: 0 | (Z vbtable pointer)
// CHECK-X64-NEXT: 8 | char a
// CHECK-X64-NEXT: 10 | int b
// CHECK-X64-NEXT: 16 | struct B (virtual base)
// CHECK-X64-NEXT: 16 | long long a
// CHECK-X64-NEXT: | [sizeof=24, align=4
// CHECK-X64-NEXT: | nvsize=14, nvalign=4]
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
#pragma pack(pop)
[ms-abi] Makes Virtual Base Alignment Look at All Virtual Bases Prior to this patch, the alignment imposed by virtual bases only included direct virtual bases. This patch fixes it to look at all virtual bases. llvm-svn: 196997
2013-12-11 10:21:03 +08:00
struct A1 { long long a; };
#pragma pack(push, 1)
struct B1 : virtual A1 { char a; };
#pragma pack(pop)
struct C1 : B1 {};
[ms-abi] Fixes improperly sized vfptrs with pragma pack With pragma pack, the layout engine would produce vfptrs that were packed width rather than pointer width. This patch addresses the issue and adds a test case. llvm-svn: 198059
2013-12-27 06:09:12 +08:00
[ms-abi] Makes Virtual Base Alignment Look at All Virtual Bases Prior to this patch, the alignment imposed by virtual bases only included direct virtual bases. This patch fixes it to look at all virtual bases. llvm-svn: 196997
2013-12-11 10:21:03 +08:00
// CHECK: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct C1
// CHECK-NEXT: 0 | struct B1 (base)
// CHECK-NEXT: 0 | (B1 vbtable pointer)
// CHECK-NEXT: 4 | char a
// CHECK-NEXT: 8 | struct A1 (virtual base)
// CHECK-NEXT: 8 | long long a
// CHECK-NEXT: | [sizeof=16, align=8
// CHECK-NEXT: | nvsize=5, nvalign=8]
[ms-abi] Makes Virtual Base Alignment Look at All Virtual Bases Prior to this patch, the alignment imposed by virtual bases only included direct virtual bases. This patch fixes it to look at all virtual bases. llvm-svn: 196997
2013-12-11 10:21:03 +08:00
// CHECK-X64: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct C1
// CHECK-X64-NEXT: 0 | struct B1 (base)
// CHECK-X64-NEXT: 0 | (B1 vbtable pointer)
// CHECK-X64-NEXT: 8 | char a
// CHECK-X64-NEXT: 16 | struct A1 (virtual base)
// CHECK-X64-NEXT: 16 | long long a
// CHECK-X64-NEXT: | [sizeof=24, align=8
// CHECK-X64-NEXT: | nvsize=9, nvalign=8]
[ms-abi] Makes Virtual Base Alignment Look at All Virtual Bases Prior to this patch, the alignment imposed by virtual bases only included direct virtual bases. This patch fixes it to look at all virtual bases. llvm-svn: 196997
2013-12-11 10:21:03 +08:00
[ms-abi] Fixes improperly sized vfptrs with pragma pack With pragma pack, the layout engine would produce vfptrs that were packed width rather than pointer width. This patch addresses the issue and adds a test case. llvm-svn: 198059
2013-12-27 06:09:12 +08:00
struct CA0 {
CA0() {}
};
struct CA1 : virtual CA0 {
CA1() {}
};
#pragma pack(push, 1)
struct CA2 : public CA1, public CA0 {
virtual void CA2Method() {}
CA2() {}
};
#pragma pack(pop)
// CHECK: *** Dumping AST Record Layout
[ms-abi] Refactor Microsoft Record Layout This patch refactors microsoft record layout to be more "natural". The most dominant change is that vbptrs and vfptrs are injected after the fact. This simplifies the implementation and the math for the offest for the first base/field after the vbptr. llvm-svn: 198818
2014-01-09 08:30:56 +08:00
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct CA2
// CHECK-NEXT: 0 | (CA2 vftable pointer)
// CHECK-NEXT: 4 | struct CA1 (base)
// CHECK-NEXT: 4 | (CA1 vbtable pointer)
// CHECK-NEXT: 9 | struct CA0 (base) (empty)
// CHECK-NEXT: 9 | struct CA0 (virtual base) (empty)
// CHECK-NEXT: | [sizeof=9, align=1
// CHECK-NEXT: | nvsize=9, nvalign=1]
MS ABI: Fix some layout tests Some lines intended to be used for testing x86_64 ABI compatibility were not firing because lines were annotated with the wrong FileCheck prefix: X64 vs C64 llvm-svn: 201453
2014-02-15 09:09:56 +08:00
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct CA2
// CHECK-X64-NEXT: 0 | (CA2 vftable pointer)
// CHECK-X64-NEXT: 8 | struct CA1 (base)
// CHECK-X64-NEXT: 8 | (CA1 vbtable pointer)
// CHECK-X64-NEXT: 17 | struct CA0 (base) (empty)
// CHECK-X64-NEXT: 17 | struct CA0 (virtual base) (empty)
// CHECK-X64-NEXT: | [sizeof=17, align=1
// CHECK-X64-NEXT: | nvsize=17, nvalign=1]
[ms-abi] Fixes improperly sized vfptrs with pragma pack With pragma pack, the layout engine would produce vfptrs that were packed width rather than pointer width. This patch addresses the issue and adds a test case. llvm-svn: 198059
2013-12-27 06:09:12 +08:00
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
#pragma pack(16)
struct YA {
__declspec(align(32)) char : 1;
};
// CHECK: *** Dumping AST Record Layout
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-NEXT: 0 | struct YA
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT:0:0-0 | char
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-NEXT: | [sizeof=32, align=32
// CHECK-NEXT: | nvsize=32, nvalign=32]
// CHECK-X64: *** Dumping AST Record Layout
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-X64-NEXT: 0 | struct YA
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT:0:0-0 | char
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-X64-NEXT: | [sizeof=32, align=32
// CHECK-X64-NEXT: | nvsize=32, nvalign=32]
#pragma pack(1)
struct YB {
char a;
YA b;
};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct YB
// CHECK-NEXT: 0 | char a
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-NEXT: 1 | struct YA b
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT:1:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=33, align=1
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-NEXT: | nvsize=33, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct YB
// CHECK-X64-NEXT: 0 | char a
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-X64-NEXT: 1 | struct YA b
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT:1:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=33, align=1
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-X64-NEXT: | nvsize=33, nvalign=1]
#pragma pack(8)
struct YC {
__declspec(align(32)) char : 1;
};
// CHECK: *** Dumping AST Record Layout
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-NEXT: 0 | struct YC
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT:0:0-0 | char
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-NEXT: | [sizeof=32, align=32
// CHECK-NEXT: | nvsize=32, nvalign=32]
// CHECK-X64: *** Dumping AST Record Layout
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-X64-NEXT: 0 | struct YC
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 0:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=8, align=32
// CHECK-X64-NEXT: | nvsize=8, nvalign=32]
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
#pragma pack(1)
struct YD {
char a;
YC b;
};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct YD
// CHECK-NEXT: 0 | char a
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-NEXT: 1 | struct YC b
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT:1:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=33, align=1
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-NEXT: | nvsize=33, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct YD
// CHECK-X64-NEXT: 0 | char a
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-X64-NEXT: 1 | struct YC b
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT:1:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=9, align=1
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-X64-NEXT: | nvsize=9, nvalign=1]
#pragma pack(4)
struct YE {
__declspec(align(32)) char : 1;
};
// CHECK: *** Dumping AST Record Layout
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-NEXT: 0 | struct YE
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT: 0:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=4, align=32
// CHECK-NEXT: | nvsize=4, nvalign=32]
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-X64: *** Dumping AST Record Layout
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-X64-NEXT: 0 | struct YE
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 0:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=4, align=32
// CHECK-X64-NEXT: | nvsize=4, nvalign=32]
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
#pragma pack(1)
struct YF {
char a;
YE b;
};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct YF
// CHECK-NEXT: 0 | char a
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-NEXT: 1 | struct YE b
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT:1:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=5, align=1
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-NEXT: | nvsize=5, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct YF
// CHECK-X64-NEXT: 0 | char a
Non-zero-length bit-fields make a class non-empty. This implements the rule intended by the standard (see LWG 2358) and the rule intended by the Itanium C++ ABI (see https://github.com/itanium-cxx-abi/cxx-abi/pull/51), and makes Clang match the behavior of GCC, ICC, and MSVC. A pedantic reading of both the standard and the ABI indicate that Clang is currently technically correct, but that's not worth much when it's clear that the wording is wrong in both those places. This is an ABI break for classes that derive from a class that is empty other than one or more unnamed non-zero-length bit-fields. Such cases are expected to be rare, but -fclang-abi-compat=6 restores the old behavior just in case. Differential Revision: https://reviews.llvm.org/D45174 llvm-svn: 331620
2018-05-07 14:43:30 +08:00
// CHECK-X64-NEXT: 1 | struct YE b
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT:1:0-0 | char
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=5, align=1
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
// CHECK-X64-NEXT: | nvsize=5, nvalign=1]
[ms-abi] Change the way alignment is tracked This patch more cleanly seperates the concepts of Preferred Alignment and Required Alignment. Most notable that changes to Required Alignment do *not* impact preferred alignment until late in struct layout. This is observable when using pragma pack and non-virtual bases and the use of tail padding when laying them out. Test cases included. llvm-svn: 198988
2014-01-11 09:16:40 +08:00
#pragma pack(16)
struct __declspec(align(16)) D0 { char a; };
#pragma pack(1)
struct D1 : public D0 { char a; };
#pragma pack(16)
struct D2 : D1 { char a; };
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct D2
// CHECK-NEXT: 0 | struct D1 (base)
// CHECK-NEXT: 0 | struct D0 (base)
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 1 | char a
// CHECK-NEXT: 2 | char a
// CHECK-NEXT: | [sizeof=16, align=16
// CHECK-NEXT: | nvsize=16, nvalign=16]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct D2
// CHECK-X64-NEXT: 0 | struct D1 (base)
// CHECK-X64-NEXT: 0 | struct D0 (base)
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 1 | char a
// CHECK-X64-NEXT: 2 | char a
// CHECK-X64-NEXT: | [sizeof=16, align=16
// CHECK-X64-NEXT: | nvsize=16, nvalign=16]
[ms-abi] Reordering __declspec(align) pragma pack handling This patch moves the check for pragma pack until after the application of __declspec align to before pragma pack. This causes observable changes in the use of tail padding for bases. A test case is included. llvm-svn: 199154
2014-01-14 06:25:55 +08:00
#pragma pack()
struct JA { char a; };
#pragma pack(1)
struct JB { __declspec(align(4)) char a; };
#pragma pack()
struct JC : JB, JA { };
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct JC
// CHECK-NEXT: 0 | struct JB (base)
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 1 | struct JA (base)
// CHECK-NEXT: 1 | char a
// CHECK-NEXT: | [sizeof=4, align=4
// CHECK-NEXT: | nvsize=4, nvalign=4]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct JC
// CHECK-X64-NEXT: 0 | struct JB (base)
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 1 | struct JA (base)
// CHECK-X64-NEXT: 1 | char a
// CHECK-X64-NEXT: | [sizeof=4, align=4
// CHECK-X64-NEXT: | nvsize=4, nvalign=4]
[ms-abi] Small Change to pack+alignment interaction. This patch makes a small behavioral change to the interaction between pack and alignment. Specifically it makes __declspec(align()) on a field change that field's alignment without respect to pack but the alignment change to the record alignment as a whole still obeys pack. llvm-svn: 199172
2014-01-14 08:54:36 +08:00
#pragma pack()
struct KA { char a; };
#pragma pack(1)
struct KB : KA { __declspec(align(2)) char a; };
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct KB
// CHECK-NEXT: 0 | struct KA (base)
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 2 | char a
// CHECK-NEXT: | [sizeof=4, align=2
// CHECK-NEXT: | nvsize=3, nvalign=2]
MS ABI: Fix some layout tests Some lines intended to be used for testing x86_64 ABI compatibility were not firing because lines were annotated with the wrong FileCheck prefix: X64 vs x64 N.B. Changes beyond just changing x64 to X64 were made, presumably because other parts of the layout engine have changed. I've verified the changes to make sure that MSVC creates a compatible layout. llvm-svn: 200670
2014-02-03 08:29:57 +08:00
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct KB
// CHECK-X64-NEXT: 0 | struct KA (base)
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 2 | char a
// CHECK-X64-NEXT: | [sizeof=4, align=2
// CHECK-X64-NEXT: | nvsize=3, nvalign=2]
[ms-abi] Small Change to pack+alignment interaction. This patch makes a small behavioral change to the interaction between pack and alignment. Specifically it makes __declspec(align()) on a field change that field's alignment without respect to pack but the alignment change to the record alignment as a whole still obeys pack. llvm-svn: 199172
2014-01-14 08:54:36 +08:00
MS ABI: vptr injection should obey alignment requirements vptr injection must inject padding equivalent to the alignment of the most aligned non-virtual subobject, not the alignment of the enclosing record. To fascilitate this change, don't let record layout observe the alignment of the record until we've injected our vptrs. Also, do not allow the alignment of vbases to affect required alignment until just before we insert the vtordisp field. llvm-svn: 201199
2014-02-12 08:43:02 +08:00
#pragma pack(1)
struct L {
virtual void fun() {}
__declspec(align(256)) int Field;
};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct L
// CHECK-NEXT: 0 | (L vftable pointer)
// CHECK-NEXT: 256 | int Field
// CHECK-NEXT: | [sizeof=512, align=256
// CHECK-NEXT: | nvsize=260, nvalign=256]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct L
// CHECK-X64-NEXT: 0 | (L vftable pointer)
// CHECK-X64-NEXT: 256 | int Field
// CHECK-X64-NEXT: | [sizeof=512, align=256
// CHECK-X64-NEXT: | nvsize=260, nvalign=256]
#pragma pack()
struct MA {};
#pragma pack(1)
struct MB : virtual MA {
__declspec(align(256)) int Field;
};
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct MB
// CHECK-NEXT: 0 | (MB vbtable pointer)
// CHECK-NEXT: 256 | int Field
// CHECK-NEXT: 260 | struct MA (virtual base) (empty)
// CHECK-NEXT: | [sizeof=512, align=256
// CHECK-NEXT: | nvsize=260, nvalign=256]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct MB
// CHECK-X64-NEXT: 0 | (MB vbtable pointer)
// CHECK-X64-NEXT: 256 | int Field
// CHECK-X64-NEXT: 260 | struct MA (virtual base) (empty)
// CHECK-X64-NEXT: | [sizeof=512, align=256
// CHECK-X64-NEXT: | nvsize=260, nvalign=256]
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
struct RA {};
#pragma pack(1)
struct __declspec(align(8)) RB0 {
__declspec(align(1024)) int b : 3;
};
struct __declspec(align(8)) RB1 {
__declspec(align(1024)) int b : 3;
virtual void f() {}
};
struct __declspec(align(8)) RB2 : virtual RA {
__declspec(align(1024)) int b : 3;
};
struct __declspec(align(8)) RB3 : virtual RA {
__declspec(align(1024)) int b : 3;
virtual void f() {}
};
struct RC {
char _;
__declspec(align(1024)) int c : 3;
};
struct RE {
char _;
RC c;
};
#pragma pack()
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct RB0
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT:0:0-2 | int b
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=8, align=1024
// CHECK-NEXT: | nvsize=4, nvalign=1024]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct RB1
// CHECK-NEXT: 0 | (RB1 vftable pointer)
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT: 1024:0-2 | int b
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=1032, align=1024
// CHECK-NEXT: | nvsize=1028, nvalign=1024]
// CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct RB2
// CHECK-NEXT: 0 | (RB2 vbtable pointer)
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT: 1024:0-2 | int b
[MS-ABI] Update virtual base padding rules to match MSVC 10+ In version 9 (VS2010) (and prior)? versions of msvc, if the last field in a record was a bitfield padding equal to the size of the storage class of that bitfield was added before each vbase and vtordisp. This patch removes that feature from clang and updates the lit tests to reflect it. llvm-svn: 206004
2014-04-11 08:14:09 +08:00
// CHECK-NEXT: 1028 | struct RA (virtual base) (empty)
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=1032, align=1024
// CHECK-NEXT: | nvsize=1028, nvalign=1024]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct RB3
// CHECK-NEXT: 0 | (RB3 vftable pointer)
// CHECK-NEXT: 1024 | (RB3 vbtable pointer)
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT: 2048:0-2 | int b
[MS-ABI] Update virtual base padding rules to match MSVC 10+ In version 9 (VS2010) (and prior)? versions of msvc, if the last field in a record was a bitfield padding equal to the size of the storage class of that bitfield was added before each vbase and vtordisp. This patch removes that feature from clang and updates the lit tests to reflect it. llvm-svn: 206004
2014-04-11 08:14:09 +08:00
// CHECK-NEXT: 2052 | struct RA (virtual base) (empty)
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=2056, align=1024
// CHECK-NEXT: | nvsize=2052, nvalign=1024]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct RC
// CHECK-NEXT: 0 | char _
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT: 1024:0-2 | int c
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=1028, align=1024
// CHECK-NEXT: | nvsize=1028, nvalign=1024]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct RE
// CHECK-NEXT: 0 | char _
// CHECK-NEXT: 1 | struct RC c
// CHECK-NEXT: 1 | char _
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT: 1025:0-2 | int c
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-NEXT: | [sizeof=1029, align=1
// CHECK-NEXT: | nvsize=1029, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct RB0
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 0:0-2 | int b
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=8, align=1024
// CHECK-X64-NEXT: | nvsize=4, nvalign=1024]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct RB1
// CHECK-X64-NEXT: 0 | (RB1 vftable pointer)
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 1024:0-2 | int b
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=1032, align=1024
// CHECK-X64-NEXT: | nvsize=1028, nvalign=1024]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct RB2
// CHECK-X64-NEXT: 0 | (RB2 vbtable pointer)
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 1024:0-2 | int b
[MS-ABI] Update virtual base padding rules to match MSVC 10+ In version 9 (VS2010) (and prior)? versions of msvc, if the last field in a record was a bitfield padding equal to the size of the storage class of that bitfield was added before each vbase and vtordisp. This patch removes that feature from clang and updates the lit tests to reflect it. llvm-svn: 206004
2014-04-11 08:14:09 +08:00
// CHECK-X64-NEXT: 1028 | struct RA (virtual base) (empty)
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=1032, align=1024
// CHECK-X64-NEXT: | nvsize=1028, nvalign=1024]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct RB3
// CHECK-X64-NEXT: 0 | (RB3 vftable pointer)
// CHECK-X64-NEXT: 1024 | (RB3 vbtable pointer)
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 2048:0-2 | int b
[MS-ABI] Update virtual base padding rules to match MSVC 10+ In version 9 (VS2010) (and prior)? versions of msvc, if the last field in a record was a bitfield padding equal to the size of the storage class of that bitfield was added before each vbase and vtordisp. This patch removes that feature from clang and updates the lit tests to reflect it. llvm-svn: 206004
2014-04-11 08:14:09 +08:00
// CHECK-X64-NEXT: 2052 | struct RA (virtual base) (empty)
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=2056, align=1024
// CHECK-X64-NEXT: | nvsize=2052, nvalign=1024]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct RC
// CHECK-X64-NEXT: 0 | char _
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 1024:0-2 | int c
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=1028, align=1024
// CHECK-X64-NEXT: | nvsize=1028, nvalign=1024]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct RE
// CHECK-X64-NEXT: 0 | char _
// CHECK-X64-NEXT: 1 | struct RC c
// CHECK-X64-NEXT: 1 | char _
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT: 1025:0-2 | int c
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
// CHECK-X64-NEXT: | [sizeof=1029, align=1
// CHECK-X64-NEXT: | nvsize=1029, nvalign=1]
MS ABI: Up the required alignment after inserting padding between vbases We would correctly insert sufficiently aligned padding between vbases when our leading base was empty, however we would neglect to increase the required alignment of the most derived class. This fixes PR20315. llvm-svn: 213123
2014-07-16 15:16:58 +08:00
struct NA {};
struct NB {};
#pragma pack(push, 1)
struct NC : virtual NA, virtual NB {};
#pragma pack(pop)
struct ND : NC {};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct NA (empty)
// CHECK-NEXT: | [sizeof=1, align=1
// CHECK-NEXT: | nvsize=0, nvalign=1]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct NB (empty)
// CHECK-NEXT: | [sizeof=1, align=1
// CHECK-NEXT: | nvsize=0, nvalign=1]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct NC
// CHECK-NEXT: 0 | (NC vbtable pointer)
// CHECK-NEXT: 4 | struct NA (virtual base) (empty)
// CHECK-NEXT: 8 | struct NB (virtual base) (empty)
// CHECK-NEXT: | [sizeof=8, align=1
// CHECK-NEXT: | nvsize=4, nvalign=1]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct ND
// CHECK-NEXT: 0 | struct NC (base)
// CHECK-NEXT: 0 | (NC vbtable pointer)
// CHECK-NEXT: 4 | struct NA (virtual base) (empty)
// CHECK-NEXT: 8 | struct NB (virtual base) (empty)
// CHECK-NEXT: | [sizeof=8, align=4
// CHECK-NEXT: | nvsize=4, nvalign=4]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct NA (empty)
// CHECK-X64-NEXT: | [sizeof=1, align=1
// CHECK-X64-NEXT: | nvsize=0, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct NB (empty)
// CHECK-X64-NEXT: | [sizeof=1, align=1
// CHECK-X64-NEXT: | nvsize=0, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct NC
// CHECK-X64-NEXT: 0 | (NC vbtable pointer)
// CHECK-X64-NEXT: 8 | struct NA (virtual base) (empty)
// CHECK-X64-NEXT: 12 | struct NB (virtual base) (empty)
// CHECK-X64-NEXT: | [sizeof=12, align=1
// CHECK-X64-NEXT: | nvsize=8, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct ND
// CHECK-X64-NEXT: 0 | struct NC (base)
// CHECK-X64-NEXT: 0 | (NC vbtable pointer)
// CHECK-X64-NEXT: 8 | struct NA (virtual base) (empty)
// CHECK-X64-NEXT: 12 | struct NB (virtual base) (empty)
// CHECK-X64-NEXT: | [sizeof=12, align=4
// CHECK-X64-NEXT: | nvsize=8, nvalign=4]
MS ABI: Padding injected between empty vbases doesn't up required align Only alignment is changed, not required alignment. llvm-svn: 213217
2014-07-17 08:55:19 +08:00
struct OA {};
struct OB {};
struct OC : virtual OA, virtual OB {};
#pragma pack(push, 1)
struct OD : OC {};
#pragma pack(pop)
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct OA (empty)
// CHECK-NEXT: | [sizeof=1, align=1
// CHECK-NEXT: | nvsize=0, nvalign=1]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct OB (empty)
// CHECK-NEXT: | [sizeof=1, align=1
// CHECK-NEXT: | nvsize=0, nvalign=1]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct OC
// CHECK-NEXT: 0 | (OC vbtable pointer)
// CHECK-NEXT: 4 | struct OA (virtual base) (empty)
// CHECK-NEXT: 8 | struct OB (virtual base) (empty)
// CHECK-NEXT: | [sizeof=8, align=4
// CHECK-NEXT: | nvsize=4, nvalign=4]
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct OD
// CHECK-NEXT: 0 | struct OC (base)
// CHECK-NEXT: 0 | (OC vbtable pointer)
// CHECK-NEXT: 4 | struct OA (virtual base) (empty)
// CHECK-NEXT: 8 | struct OB (virtual base) (empty)
// CHECK-NEXT: | [sizeof=8, align=1
// CHECK-NEXT: | nvsize=4, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct OA (empty)
// CHECK-X64-NEXT: | [sizeof=1, align=1
// CHECK-X64-NEXT: | nvsize=0, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct OB (empty)
// CHECK-X64-NEXT: | [sizeof=1, align=1
// CHECK-X64-NEXT: | nvsize=0, nvalign=1]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct OC
// CHECK-X64-NEXT: 0 | (OC vbtable pointer)
// CHECK-X64-NEXT: 8 | struct OA (virtual base) (empty)
// CHECK-X64-NEXT: 12 | struct OB (virtual base) (empty)
// CHECK-X64-NEXT: | [sizeof=16, align=8
// CHECK-X64-NEXT: | nvsize=8, nvalign=8]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct OD
// CHECK-X64-NEXT: 0 | struct OC (base)
// CHECK-X64-NEXT: 0 | (OC vbtable pointer)
// CHECK-X64-NEXT: 8 | struct OA (virtual base) (empty)
// CHECK-X64-NEXT: 12 | struct OB (virtual base) (empty)
// CHECK-X64-NEXT: | [sizeof=12, align=1
// CHECK-X64-NEXT: | nvsize=8, nvalign=1]
MS ABI: Consider alignment attributes on typedefs for layout The MS ABI has a notion of 'required alignment' for fields; this alignment supercedes pragma pack directives. MSVC takes into account alignment attributes on typedefs when determining whether or not a field has a certain required alignment. Do the same in clang by tracking whether or not we saw such an attribute when calculating the type's bitwidth and alignment. This fixes PR20418. Reviewers: rnk Differential Revision: http://reviews.llvm.org/D4714 llvm-svn: 214274
2014-07-30 09:30:47 +08:00
struct __declspec(align(4)) PA {
int c;
};
typedef __declspec(align(8)) PA PB;
#pragma pack(push, 1)
struct PC {
char a;
PB x;
};
#pragma pack(pop)
// CHECK: *** Dumping AST Record Layout
// CHECK: 0 | struct PC
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 8 | struct PA x
// CHECK-NEXT: 8 | int c
// CHECK-NEXT: | [sizeof=16, align=8
// CHECK-NEXT: | nvsize=12, nvalign=8]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: 0 | struct PC
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 8 | struct PA x
// CHECK-X64-NEXT: 8 | int c
// CHECK-X64-NEXT: | [sizeof=16, align=8
// CHECK-X64-NEXT: | nvsize=12, nvalign=8]
AST: Propagate 'AlignIsRequired' though many levels of typedefs A typedef of a typedef should have AlignIsRequired if *either* typedef has an AlignAttr attached to it. llvm-svn: 214698
2014-08-04 13:11:01 +08:00
typedef PB PD;
#pragma pack(push, 1)
struct PE {
char a;
PD x;
};
#pragma pack(pop)
// CHECK: *** Dumping AST Record Layout
// CHECK: 0 | struct PE
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 8 | struct PA x
// CHECK-NEXT: 8 | int c
// CHECK-NEXT: | [sizeof=16, align=8
// CHECK-NEXT: | nvsize=12, nvalign=8]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: 0 | struct PE
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 8 | struct PA x
// CHECK-X64-NEXT: 8 | int c
// CHECK-X64-NEXT: | [sizeof=16, align=8
// CHECK-X64-NEXT: | nvsize=12, nvalign=8]
MS ABI: Consider alignment attributes on typedefs for layout The MS ABI has a notion of 'required alignment' for fields; this alignment supercedes pragma pack directives. MSVC takes into account alignment attributes on typedefs when determining whether or not a field has a certain required alignment. Do the same in clang by tracking whether or not we saw such an attribute when calculating the type's bitwidth and alignment. This fixes PR20418. Reviewers: rnk Differential Revision: http://reviews.llvm.org/D4714 llvm-svn: 214274
2014-07-30 09:30:47 +08:00
typedef int __declspec(align(2)) QA;
#pragma pack(push, 1)
struct QB {
char a;
QA b;
};
#pragma pack(pop)
MS ABI: Padding injected between empty vbases doesn't up required align Only alignment is changed, not required alignment. llvm-svn: 213217
2014-07-17 08:55:19 +08:00
MS ABI: Consider alignment attributes on typedefs for layout The MS ABI has a notion of 'required alignment' for fields; this alignment supercedes pragma pack directives. MSVC takes into account alignment attributes on typedefs when determining whether or not a field has a certain required alignment. Do the same in clang by tracking whether or not we saw such an attribute when calculating the type's bitwidth and alignment. This fixes PR20418. Reviewers: rnk Differential Revision: http://reviews.llvm.org/D4714 llvm-svn: 214274
2014-07-30 09:30:47 +08:00
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct QB
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 2 | QA b
// CHECK-NEXT: | [sizeof=6, align=2
// CHECK-NEXT: | nvsize=6, nvalign=2]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct QB
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 2 | QA b
// CHECK-X64-NEXT: | [sizeof=6, align=2
// CHECK-X64-NEXT: | nvsize=6, nvalign=2]
struct QC {
char a;
QA b;
};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct QC
// CHECK-NEXT: 0 | char a
// CHECK-NEXT: 4 | QA b
// CHECK-NEXT: | [sizeof=8, align=4
// CHECK-NEXT: | nvsize=8, nvalign=4]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct QC
// CHECK-X64-NEXT: 0 | char a
// CHECK-X64-NEXT: 4 | QA b
// CHECK-X64-NEXT: | [sizeof=8, align=4
// CHECK-X64-NEXT: | nvsize=8, nvalign=4]
struct QD {
char a;
QA b : 3;
};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct QD
// CHECK-NEXT: 0 | char a
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-NEXT:4:0-2 | QA b
MS ABI: Consider alignment attributes on typedefs for layout The MS ABI has a notion of 'required alignment' for fields; this alignment supercedes pragma pack directives. MSVC takes into account alignment attributes on typedefs when determining whether or not a field has a certain required alignment. Do the same in clang by tracking whether or not we saw such an attribute when calculating the type's bitwidth and alignment. This fixes PR20418. Reviewers: rnk Differential Revision: http://reviews.llvm.org/D4714 llvm-svn: 214274
2014-07-30 09:30:47 +08:00
// CHECK-NEXT: | [sizeof=8, align=4
// CHECK-NEXT: | nvsize=8, nvalign=4]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct QD
// CHECK-X64-NEXT: 0 | char a
Fix the layout of bitfields in ms_struct unions: their alignment is ignored, and they always allocate a complete storage unit. Also, change the dumping of AST record layouts: use the more readable C++-style dumping even in C, include bitfield offset information in the dump, and don't print sizeof/alignof information for fields of record type, since we don't do so for bases or other kinds of field. rdar://22275433 llvm-svn: 245514
2015-08-20 06:42:36 +08:00
// CHECK-X64-NEXT:4:0-2 | QA b
MS ABI: Consider alignment attributes on typedefs for layout The MS ABI has a notion of 'required alignment' for fields; this alignment supercedes pragma pack directives. MSVC takes into account alignment attributes on typedefs when determining whether or not a field has a certain required alignment. Do the same in clang by tracking whether or not we saw such an attribute when calculating the type's bitwidth and alignment. This fixes PR20418. Reviewers: rnk Differential Revision: http://reviews.llvm.org/D4714 llvm-svn: 214274
2014-07-30 09:30:47 +08:00
// CHECK-X64-NEXT: | [sizeof=8, align=4
// CHECK-X64-NEXT: | nvsize=8, nvalign=4]
MS ABI: Padding injected between empty vbases doesn't up required align Only alignment is changed, not required alignment. llvm-svn: 213217
2014-07-17 08:55:19 +08:00
MS ABI: Correct layout for empty records Empty records do not always have size equivalent to their alignment. They only do so when their alignment is at least as large as the minimum empty struct size: 1 byte in C++ and 4 bytes in C. llvm-svn: 218661
2014-09-30 14:45:43 +08:00
struct __declspec(align(4)) EmptyAlignedLongLongMemb {
long long FlexArrayMemb[0];
};
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct EmptyAlignedLongLongMemb
// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
// CHECK-NEXT: | [sizeof=8, align=8
// CHECK-NEXT: | nvsize=0, nvalign=8]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct EmptyAlignedLongLongMemb
// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb
// CHECK-X64-NEXT: | [sizeof=8, align=8
// CHECK-X64-NEXT: | nvsize=0, nvalign=8]
#pragma pack(1)
struct __declspec(align(4)) EmptyPackedAlignedLongLongMemb {
long long FlexArrayMemb[0];
};
#pragma pack()
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct EmptyPackedAlignedLongLongMemb
// CHECK-NEXT: 0 | long long [0] FlexArrayMemb
// CHECK-NEXT: | [sizeof=4, align=4
// CHECK-NEXT: | nvsize=0, nvalign=4]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64-NEXT: 0 | struct EmptyPackedAlignedLongLongMemb
// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb
// CHECK-X64-NEXT: | [sizeof=4, align=4
// CHECK-X64-NEXT: | nvsize=0, nvalign=4]
Support MS-ABI's concept of "Required Alignment" imposed by __declspec(align()) This patch implements required alignment in a way that makes __declspec(align()) and #pragma pack play correctly together. In the MS-ABI, __declspec(align()) is a hard rule and cannot be overridden by #pragma pack. This cases each record to have two interesting alignments "preferred alignment" (which matches Itanium's concept of alignment) and "required alignment" which is an alignment that must never be violated, even in the case of #pragma pack. This patch introduces the concept of Required Alignment to the record builder and tracks/uses it appropriately. Test cases are included. Differential Revision: http://llvm-reviews.chandlerc.com/D2283 llvm-svn: 196549
2013-12-06 08:01:17 +08:00
int a[
sizeof(X)+
sizeof(Y)+
[ms-abi] Makes Virtual Base Alignment Look at All Virtual Bases Prior to this patch, the alignment imposed by virtual bases only included direct virtual bases. This patch fixes it to look at all virtual bases. llvm-svn: 196997
2013-12-11 10:21:03 +08:00
sizeof(Z)+
[ms-abi] Fixes improperly sized vfptrs with pragma pack With pragma pack, the layout engine would produce vfptrs that were packed width rather than pointer width. This patch addresses the issue and adds a test case. llvm-svn: 198059
2013-12-27 06:09:12 +08:00
sizeof(C1)+
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
sizeof(CA2)+
sizeof(YA)+
sizeof(YB)+
sizeof(YC)+
sizeof(YD)+
sizeof(YE)+
sizeof(YF)+
[ms-abi] Change the way alignment is tracked This patch more cleanly seperates the concepts of Preferred Alignment and Required Alignment. Most notable that changes to Required Alignment do *not* impact preferred alignment until late in struct layout. This is observable when using pragma pack and non-virtual bases and the use of tail padding when laying them out. Test cases included. llvm-svn: 198988
2014-01-11 09:16:40 +08:00
sizeof(YF)+
sizeof(D2)+
[ms-abi] Reordering __declspec(align) pragma pack handling This patch moves the check for pragma pack until after the application of __declspec align to before pragma pack. This causes observable changes in the use of tail padding for bases. A test case is included. llvm-svn: 199154
2014-01-14 06:25:55 +08:00
sizeof(JC)+
[ms-abi] Small Change to pack+alignment interaction. This patch makes a small behavioral change to the interaction between pack and alignment. Specifically it makes __declspec(align()) on a field change that field's alignment without respect to pack but the alignment change to the record alignment as a whole still obeys pack. llvm-svn: 199172
2014-01-14 08:54:36 +08:00
sizeof(KB)+
MS ABI: vptr injection should obey alignment requirements vptr injection must inject padding equivalent to the alignment of the most aligned non-virtual subobject, not the alignment of the enclosing record. To fascilitate this change, don't let record layout observe the alignment of the record until we've injected our vptrs. Also, do not allow the alignment of vbases to affect required alignment until just before we insert the vtordisp field. llvm-svn: 201199
2014-02-12 08:43:02 +08:00
sizeof(L)+
sizeof(MB)+
[MS-ABI] Fixed __declspec(align()) on bitfields under #pragma pack. When __declspec(align()) is applied to a bitfield it affects the alignment rather than the required alignment of the struct. The major feature that this patch adds is that the alignment of the structure obeys the alignment of __declspec(align()) from the bitfield over the value specified in pragma pack. Test cases are included. The patch also includes some small cleanups in recordlayoutbuilder and some cleanups to some lit tests, including line endings (but no functionality change to lit tests) llvm-svn: 205994
2014-04-11 06:15:18 +08:00
sizeof(RB0)+
sizeof(RB1)+
sizeof(RB2)+
sizeof(RB3)+
sizeof(RC)+
sizeof(RE)+
MS ABI: Up the required alignment after inserting padding between vbases We would correctly insert sufficiently aligned padding between vbases when our leading base was empty, however we would neglect to increase the required alignment of the most derived class. This fixes PR20315. llvm-svn: 213123
2014-07-16 15:16:58 +08:00
sizeof(ND)+
MS ABI: Padding injected between empty vbases doesn't up required align Only alignment is changed, not required alignment. llvm-svn: 213217
2014-07-17 08:55:19 +08:00
sizeof(OD)+
MS ABI: Consider alignment attributes on typedefs for layout The MS ABI has a notion of 'required alignment' for fields; this alignment supercedes pragma pack directives. MSVC takes into account alignment attributes on typedefs when determining whether or not a field has a certain required alignment. Do the same in clang by tracking whether or not we saw such an attribute when calculating the type's bitwidth and alignment. This fixes PR20418. Reviewers: rnk Differential Revision: http://reviews.llvm.org/D4714 llvm-svn: 214274
2014-07-30 09:30:47 +08:00
sizeof(PC)+
AST: Propagate 'AlignIsRequired' though many levels of typedefs A typedef of a typedef should have AlignIsRequired if *either* typedef has an AlignAttr attached to it. llvm-svn: 214698
2014-08-04 13:11:01 +08:00
sizeof(PE)+
MS ABI: Consider alignment attributes on typedefs for layout The MS ABI has a notion of 'required alignment' for fields; this alignment supercedes pragma pack directives. MSVC takes into account alignment attributes on typedefs when determining whether or not a field has a certain required alignment. Do the same in clang by tracking whether or not we saw such an attribute when calculating the type's bitwidth and alignment. This fixes PR20418. Reviewers: rnk Differential Revision: http://reviews.llvm.org/D4714 llvm-svn: 214274
2014-07-30 09:30:47 +08:00
sizeof(QB)+
sizeof(QC)+
sizeof(QD)+
MS ABI: Correct layout for empty records Empty records do not always have size equivalent to their alignment. They only do so when their alignment is at least as large as the minimum empty struct size: 1 byte in C++ and 4 bytes in C. llvm-svn: 218661
2014-09-30 14:45:43 +08:00
sizeof(EmptyAlignedLongLongMemb)+
sizeof(EmptyPackedAlignedLongLongMemb)+
[ms-abi] Handle __declspec(align) on bitfields "properly" __declspec(align), when applied to bitfields affects their perferred alignment instead of their required alignment. We don't know why. Also, #pragma pack(n) turns packing *off* if n is greater than the pointer size. This is now observable because of the impact of declspec(align) on bitfields. llvm-svn: 198907
2014-01-10 09:28:05 +08:00
0];