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-aligned-tail-padding...

535 lines
17 KiB
C++
Raw Normal View History

Remove the -cxx-abi command-line flag. This makes the C++ ABI depend entirely on the target: MS ABI for -win32 triples, Itanium otherwise. It's no longer possible to do weird combinations. To be able to run a test with a specific ABI without constraining it to a specific triple, new substitutions are added to lit: %itanium_abi_triple and %ms_abi_triple can be used to get the current target triple adjusted to the desired ABI. For example, if the test suite is running with the i686-pc-win32 target, %itanium_abi_triple will expand to i686-pc-mingw32. Differential Revision: http://llvm-reviews.chandlerc.com/D2545 llvm-svn: 199250
2014-01-15 03:35:09 +08:00
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
// RUN: | FileCheck %s
Remove the -cxx-abi command-line flag. This makes the C++ ABI depend entirely on the target: MS ABI for -win32 triples, Itanium otherwise. It's no longer possible to do weird combinations. To be able to run a test with a specific ABI without constraining it to a specific triple, new substitutions are added to lit: %itanium_abi_triple and %ms_abi_triple can be used to get the current target triple adjusted to the desired ABI. For example, if the test suite is running with the i686-pc-win32 target, %itanium_abi_triple will expand to i686-pc-mingw32. Differential Revision: http://llvm-reviews.chandlerc.com/D2545 llvm-svn: 199250
2014-01-15 03:35:09 +08:00
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +08:00
// RUN: | FileCheck %s -check-prefix CHECK-X64
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
extern "C" int printf(const char *fmt, ...);
struct B0 {
int a;
B0() : a(0xf00000B0) {}
};
struct __declspec(align(16)) B1 {
int a;
B1() : a(0xf00000B1) {}
};
struct B2 {
__declspec(align(16)) int a;
B2() : a(0xf00000B2) {}
};
struct __declspec(align(16)) B3 {
long long a1;
int a;
B3() : a(0xf00000B3), a1(0xf00000B3f00000B3ll) {}
};
struct V {
char a;
V() : a(0X11) {}
};
struct __declspec(align(32)) A16 {};
struct V1 : A16 { virtual void f() {} };
struct V2 {
long long a;
int a1;
V2() : a(0xf0000011f0000011ll), a1(0xf0000011) {}
};
struct V3 {
int a;
V3() : a(0xf0000022) {}
};
struct __declspec(align(16)) A16X {
};
struct __declspec(align(16)) B0X {
int a, a1;
B0X() : a(0xf00000B0), a1(0xf00000B0) {}
};
struct B1X {
int a;
B1X() : a(0xf00000B1) {}
};
struct B2X {
int a;
B2X() : a(0xf00000B2) {}
};
struct __declspec(align(16)) B3X {
int a;
B3X() : a(0xf00000B3) {}
virtual void g() {}
};
struct B4X : A16X {
int a, a1;
B4X() : a(0xf00000B4), a1(0xf00000B4) {}
};
struct B5X : virtual A16X {
int a, a1;
B5X() : a(0xf00000B5), a1(0xf00000B5) {}
};
struct B6X {
int a;
B6X() : a(0xf00000B6) {}
};
struct A : B1, B0, B2, virtual V {
int a;
A() : a(0xf000000A) {}
};
// 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: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct A
// CHECK-NEXT: 0 | struct B1 (base)
// CHECK-NEXT: 0 | int a
// CHECK-NEXT: 4 | struct B0 (base)
// CHECK-NEXT: 4 | int a
// CHECK-NEXT: 16 | struct B2 (base)
// CHECK-NEXT: 16 | int a
// CHECK-NEXT: 32 | (A vbtable pointer)
// CHECK-NEXT: 48 | int a
// CHECK-NEXT: 64 | struct V (virtual base)
// CHECK-NEXT: 64 | char a
// CHECK-NEXT: | [sizeof=80, align=16
// CHECK-NEXT: | nvsize=64, nvalign=16]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 A
// CHECK-X64-NEXT: 0 | struct B1 (base)
// CHECK-X64-NEXT: 0 | int a
// CHECK-X64-NEXT: 4 | struct B0 (base)
// CHECK-X64-NEXT: 4 | int a
// CHECK-X64-NEXT: 16 | struct B2 (base)
// CHECK-X64-NEXT: 16 | int a
// CHECK-X64-NEXT: 32 | (A vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 48 | int a
// CHECK-X64-NEXT: 64 | struct V (virtual base)
// CHECK-X64-NEXT: 64 | char a
// CHECK-X64-NEXT: | [sizeof=80, align=16
// CHECK-X64-NEXT: | nvsize=64, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct B : B2, B0, B1, virtual V {
int a;
B() : a(0xf000000B) {}
};
// 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 B
// CHECK-NEXT: 0 | struct B2 (base)
// CHECK-NEXT: 0 | int a
// CHECK-NEXT: 16 | struct B0 (base)
// CHECK-NEXT: 16 | int a
// CHECK-NEXT: 32 | struct B1 (base)
// CHECK-NEXT: 32 | int a
// CHECK-NEXT: 36 | (B vbtable pointer)
// CHECK-NEXT: 52 | int a
// CHECK-NEXT: 64 | struct V (virtual base)
// CHECK-NEXT: 64 | char a
// CHECK-NEXT: | [sizeof=80, align=16
// CHECK-NEXT: | nvsize=64, nvalign=16]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 B
// CHECK-X64-NEXT: 0 | struct B2 (base)
// CHECK-X64-NEXT: 0 | int a
// CHECK-X64-NEXT: 16 | struct B0 (base)
// CHECK-X64-NEXT: 16 | int a
// CHECK-X64-NEXT: 32 | struct B1 (base)
// CHECK-X64-NEXT: 32 | int a
// CHECK-X64-NEXT: 40 | (B vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 52 | int a
[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: 64 | struct V (virtual base)
// CHECK-X64-NEXT: 64 | char a
// CHECK-X64-NEXT: | [sizeof=80, align=16
// CHECK-X64-NEXT: | nvsize=64, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct C : B1, B0, virtual V {
int a;
long long a1;
C() : a(0xf000000C), a1(0xf000000Cf000000Cll) {}
};
// 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 C
// CHECK-NEXT: 0 | struct B1 (base)
// CHECK-NEXT: 0 | int a
// CHECK-NEXT: 4 | struct B0 (base)
// CHECK-NEXT: 4 | int a
// CHECK-NEXT: 8 | (C vbtable pointer)
// CHECK-NEXT: 24 | int a
// CHECK-NEXT: 32 | long long a1
// CHECK-NEXT: 48 | struct V (virtual base)
// CHECK-NEXT: 48 | char a
// CHECK-NEXT: | [sizeof=64, align=16
// CHECK-NEXT: | nvsize=48, nvalign=16]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 C
// CHECK-X64-NEXT: 0 | struct B1 (base)
// CHECK-X64-NEXT: 0 | int a
// CHECK-X64-NEXT: 4 | struct B0 (base)
// CHECK-X64-NEXT: 4 | int a
// CHECK-X64-NEXT: 8 | (C vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 24 | int a
// CHECK-X64-NEXT: 32 | long long a1
// CHECK-X64-NEXT: 48 | struct V (virtual base)
// CHECK-X64-NEXT: 48 | char a
// CHECK-X64-NEXT: | [sizeof=64, align=16
// CHECK-X64-NEXT: | nvsize=48, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct D : B2, B0, virtual V {
int a;
D() : a(0xf000000D) {}
};
// 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 D
// CHECK-NEXT: 0 | struct B2 (base)
// CHECK-NEXT: 0 | int a
// CHECK-NEXT: 16 | struct B0 (base)
// CHECK-NEXT: 16 | int a
// CHECK-NEXT: 20 | (D vbtable pointer)
// CHECK-NEXT: 36 | int a
// CHECK-NEXT: 48 | struct V (virtual base)
// CHECK-NEXT: 48 | char a
// CHECK-NEXT: | [sizeof=64, align=16
// CHECK-NEXT: | nvsize=48, nvalign=16]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 D
// CHECK-X64-NEXT: 0 | struct B2 (base)
// CHECK-X64-NEXT: 0 | int a
// CHECK-X64-NEXT: 16 | struct B0 (base)
// CHECK-X64-NEXT: 16 | int a
// CHECK-X64-NEXT: 24 | (D vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 36 | int a
[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: 48 | struct V (virtual base)
// CHECK-X64-NEXT: 48 | char a
// CHECK-X64-NEXT: | [sizeof=64, align=16
// CHECK-X64-NEXT: | nvsize=48, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct E : B3, B0, virtual V {
int a;
E() : a(0xf000000E) {}
};
// 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 E
// CHECK-NEXT: 0 | struct B3 (base)
// CHECK-NEXT: 0 | long long a1
// CHECK-NEXT: 8 | int a
// CHECK-NEXT: 16 | struct B0 (base)
// CHECK-NEXT: 16 | int a
// CHECK-NEXT: 20 | (E vbtable pointer)
// CHECK-NEXT: 36 | int a
// CHECK-NEXT: 48 | struct V (virtual base)
// CHECK-NEXT: 48 | char a
// CHECK-NEXT: | [sizeof=64, align=16
// CHECK-NEXT: | nvsize=48, nvalign=16]
// CHECK-X64: *** Dumping AST Record Layout
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 E
// CHECK-X64-NEXT: 0 | struct B3 (base)
// CHECK-X64-NEXT: 0 | long long a1
// CHECK-X64-NEXT: 8 | int a
// CHECK-X64-NEXT: 16 | struct B0 (base)
// CHECK-X64-NEXT: 16 | int a
// CHECK-X64-NEXT: 24 | (E vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 36 | int a
[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: 48 | struct V (virtual base)
// CHECK-X64-NEXT: 48 | char a
// CHECK-X64-NEXT: | [sizeof=64, align=16
// CHECK-X64-NEXT: | nvsize=48, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct F : B0, virtual V1 {
__declspec(align(16)) int a;
F() : a(0xf000000F) {}
virtual void f() {}
};
// 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 F
// CHECK-NEXT: 0 | struct B0 (base)
// CHECK-NEXT: 0 | int a
// CHECK-NEXT: 4 | (F vbtable pointer)
// CHECK-NEXT: 32 | int a
// CHECK-NEXT: 92 | (vtordisp for vbase V1)
// CHECK-NEXT: 96 | struct V1 (virtual base)
// CHECK-NEXT: 96 | (V1 vftable pointer)
// CHECK-NEXT: 128 | struct A16 (base) (empty)
// CHECK-NEXT: | [sizeof=128, align=32
// CHECK-NEXT: | nvsize=48, nvalign=32]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 F
// CHECK-X64-NEXT: 0 | struct B0 (base)
// CHECK-X64-NEXT: 0 | int a
// CHECK-X64-NEXT: 8 | (F vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 32 | int a
// CHECK-X64-NEXT: 92 | (vtordisp for vbase V1)
// CHECK-X64-NEXT: 96 | struct V1 (virtual base)
// CHECK-X64-NEXT: 96 | (V1 vftable pointer)
// CHECK-X64-NEXT: 128 | struct A16 (base) (empty)
// CHECK-X64-NEXT: | [sizeof=128, align=32
// CHECK-X64-NEXT: | nvsize=48, nvalign=32]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct G : virtual V2, virtual V3 {
int a;
G() : a(0xf0000001) {}
};
// 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 G
// CHECK-NEXT: 0 | (G vbtable pointer)
// CHECK-NEXT: 4 | int a
// CHECK-NEXT: 8 | struct V2 (virtual base)
// CHECK-NEXT: 8 | long long a
// CHECK-NEXT: 16 | int a1
// CHECK-NEXT: 24 | struct V3 (virtual base)
// CHECK-NEXT: 24 | int a
// CHECK-NEXT: | [sizeof=28, align=8
// CHECK-NEXT: | nvsize=8, nvalign=8]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 G
// CHECK-X64-NEXT: 0 | (G vbtable pointer)
// CHECK-X64-NEXT: 8 | int a
// CHECK-X64-NEXT: 16 | struct V2 (virtual base)
// CHECK-X64-NEXT: 16 | long long a
// CHECK-X64-NEXT: 24 | int a1
// CHECK-X64-NEXT: 32 | struct V3 (virtual base)
// CHECK-X64-NEXT: 32 | int a
// CHECK-X64-NEXT: | [sizeof=40, align=8
// CHECK-X64-NEXT: | nvsize=16, nvalign=8]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct H {
__declspec(align(16)) int a;
int b;
H() : a(0xf0000010), b(0xf0000010) {}
};
// 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 H
// CHECK-NEXT: 0 | int a
// CHECK-NEXT: 4 | int b
// CHECK-NEXT: | [sizeof=16, align=16
// CHECK-NEXT: | nvsize=16, nvalign=16]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 H
// CHECK-X64-NEXT: 0 | int a
// CHECK-X64-NEXT: 4 | int b
// CHECK-X64-NEXT: | [sizeof=16, align=16
// CHECK-X64-NEXT: | nvsize=16, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct I {
B2 a;
int b;
I() : b(0xf0000010) {}
};
// 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 I
// CHECK-NEXT: 0 | struct B2 a
// CHECK-NEXT: 0 | int a
// CHECK: 16 | int b
// CHECK-NEXT: | [sizeof=32, align=16
// CHECK-NEXT: | nvsize=32, nvalign=16]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 I
// CHECK-X64-NEXT: 0 | struct B2 a
// CHECK-X64-NEXT: 0 | int a
// CHECK-X64: 16 | int b
// CHECK-X64-NEXT: | [sizeof=32, align=16
// CHECK-X64-NEXT: | nvsize=32, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct AX : B0X, virtual B2X, virtual B6X, virtual B3X {
int a;
AX() : a(0xf000000A) {}
virtual void f() {}
virtual void g() {}
};
// 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: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout
// CHECK-NEXT: 0 | struct AX
// CHECK-NEXT: 0 | (AX vftable pointer)
// CHECK-NEXT: 16 | struct B0X (base)
// CHECK-NEXT: 16 | int a
// CHECK-NEXT: 20 | int a1
// CHECK-NEXT: 24 | (AX vbtable pointer)
// CHECK-NEXT: 40 | int a
// CHECK-NEXT: 48 | struct B2X (virtual base)
// CHECK-NEXT: 48 | int a
// CHECK-NEXT: 52 | struct B6X (virtual base)
// CHECK-NEXT: 52 | int a
// CHECK-NEXT: 76 | (vtordisp for vbase B3X)
// CHECK-NEXT: 80 | struct B3X (virtual base)
// CHECK-NEXT: 80 | (B3X vftable pointer)
// CHECK-NEXT: 84 | int a
// CHECK-NEXT: | [sizeof=96, align=16
// CHECK-NEXT: | nvsize=48, nvalign=16]
// CHECK-X64: *** Dumping AST Record Layout
// CHECK-X64: *** Dumping AST Record Layout
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 AX
// CHECK-X64-NEXT: 0 | (AX vftable pointer)
// CHECK-X64-NEXT: 16 | struct B0X (base)
// CHECK-X64-NEXT: 16 | int a
// CHECK-X64-NEXT: 20 | int a1
// CHECK-X64-NEXT: 24 | (AX vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 40 | int a
[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: 48 | struct B2X (virtual base)
// CHECK-X64-NEXT: 48 | int a
// CHECK-X64-NEXT: 52 | struct B6X (virtual base)
// CHECK-X64-NEXT: 52 | int a
// CHECK-X64-NEXT: 76 | (vtordisp for vbase B3X)
// CHECK-X64-NEXT: 80 | struct B3X (virtual base)
// CHECK-X64-NEXT: 80 | (B3X vftable pointer)
// CHECK-X64-NEXT: 88 | int a
// CHECK-X64-NEXT: | [sizeof=96, align=16
// CHECK-X64-NEXT: | nvsize=48, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct BX : B4X, virtual B2X, virtual B6X, virtual B3X {
int a;
BX() : a(0xf000000B) {}
virtual void f() {}
virtual void g() {}
};
// 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 BX
// CHECK-NEXT: 0 | (BX vftable pointer)
// CHECK-NEXT: 16 | struct B4X (base)
// CHECK-NEXT: 16 | struct A16X (base) (empty)
// CHECK-NEXT: 16 | int a
// CHECK-NEXT: 20 | int a1
// CHECK-NEXT: 32 | (BX vbtable pointer)
// CHECK-NEXT: 48 | int a
// CHECK-NEXT: 64 | struct B2X (virtual base)
// CHECK-NEXT: 64 | int a
// CHECK-NEXT: 68 | struct B6X (virtual base)
// CHECK-NEXT: 68 | int a
// CHECK-NEXT: 92 | (vtordisp for vbase B3X)
// CHECK-NEXT: 96 | struct B3X (virtual base)
// CHECK-NEXT: 96 | (B3X vftable pointer)
// CHECK-NEXT: 100 | int a
// CHECK-NEXT: | [sizeof=112, align=16
// CHECK-NEXT: | nvsize=64, nvalign=16]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 BX
// CHECK-X64-NEXT: 0 | (BX vftable pointer)
// CHECK-X64-NEXT: 16 | struct B4X (base)
// CHECK-X64-NEXT: 16 | struct A16X (base) (empty)
// CHECK-X64-NEXT: 16 | int a
// CHECK-X64-NEXT: 20 | int a1
// CHECK-X64-NEXT: 32 | (BX vbtable pointer)
[MS-ABI] Drop Special Layout in 64-bit mode. As of cl.exe version 18, the special layout rules for structs with alignment 16 or greater has been dropped. This patch drops the behavior from clang. This patch also updates the lit tests to reflect the change. llvm-svn: 204674
2014-03-25 05:37:27 +08:00
// CHECK-X64-NEXT: 48 | int a
// CHECK-X64-NEXT: 64 | struct B2X (virtual base)
// CHECK-X64-NEXT: 64 | int a
// CHECK-X64-NEXT: 68 | struct B6X (virtual base)
// CHECK-X64-NEXT: 68 | int a
// CHECK-X64-NEXT: 92 | (vtordisp for vbase B3X)
// CHECK-X64-NEXT: 96 | struct B3X (virtual base)
// CHECK-X64-NEXT: 96 | (B3X vftable pointer)
// CHECK-X64-NEXT: 104 | int a
// CHECK-X64-NEXT: | [sizeof=112, align=16
// CHECK-X64-NEXT: | nvsize=64, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct CX : B5X, virtual B2X, virtual B6X, virtual B3X {
int a;
CX() : a(0xf000000C) {}
virtual void f() {}
virtual void g() {}
};
// 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 CX
// CHECK-NEXT: 0 | (CX vftable pointer)
// CHECK-NEXT: 16 | struct B5X (base)
// CHECK-NEXT: 16 | (B5X vbtable pointer)
// CHECK-NEXT: 20 | int a
// CHECK-NEXT: 24 | int a1
// CHECK-NEXT: 28 | int a
// CHECK-NEXT: 32 | struct A16X (virtual base) (empty)
// CHECK-NEXT: 32 | struct B2X (virtual base)
// CHECK-NEXT: 32 | int a
// CHECK-NEXT: 36 | struct B6X (virtual base)
// CHECK-NEXT: 36 | int a
// CHECK-NEXT: 60 | (vtordisp for vbase B3X)
// CHECK-NEXT: 64 | struct B3X (virtual base)
// CHECK-NEXT: 64 | (B3X vftable pointer)
// CHECK-NEXT: 68 | int a
// CHECK-NEXT: | [sizeof=80, align=16
// CHECK-NEXT: | nvsize=32, nvalign=16]
// CHECK-X64: *** Dumping AST Record Layout
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 CX
// CHECK-X64-NEXT: 0 | (CX vftable pointer)
// CHECK-X64-NEXT: 16 | struct B5X (base)
// CHECK-X64-NEXT: 16 | (B5X vbtable pointer)
// CHECK-X64-NEXT: 24 | int a
// CHECK-X64-NEXT: 28 | int a1
// CHECK-X64-NEXT: 32 | int a
// CHECK-X64-NEXT: 48 | struct A16X (virtual base) (empty)
// CHECK-X64-NEXT: 48 | struct B2X (virtual base)
// CHECK-X64-NEXT: 48 | int a
// CHECK-X64-NEXT: 52 | struct B6X (virtual base)
// CHECK-X64-NEXT: 52 | int a
// CHECK-X64-NEXT: 76 | (vtordisp for vbase B3X)
// CHECK-X64-NEXT: 80 | struct B3X (virtual base)
// CHECK-X64-NEXT: 80 | (B3X vftable pointer)
// CHECK-X64-NEXT: 88 | int a
// CHECK-X64-NEXT: | [sizeof=96, align=16
// CHECK-X64-NEXT: | nvsize=48, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
struct __declspec(align(16)) DX {
int a;
DX() : a(0xf000000D) {}
virtual void f() {}
};
// 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 DX
// CHECK-NEXT: 0 | (DX vftable pointer)
// CHECK-NEXT: 4 | int a
// CHECK-NEXT: | [sizeof=16, align=16
// CHECK-NEXT: | nvsize=8, nvalign=16]
Implements 64 bit microsoft record layout and adds lit tests to cover it. Also removes all of the microsoft C++ ABI related code from the itanium layout builder. Differential Revision: http://llvm-reviews.chandlerc.com/D2003 llvm-svn: 193290
2013-10-24 07:53:07 +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 DX
// CHECK-X64-NEXT: 0 | (DX vftable pointer)
// CHECK-X64-NEXT: 8 | int a
// CHECK-X64-NEXT: | [sizeof=16, align=16
// CHECK-X64-NEXT: | nvsize=16, nvalign=16]
Lit tests for Microsoft C++ record layout. They weren't added with the rest of the microsoft record layout patch due me not doing svn add. llvm-svn: 192612
2013-10-15 03:08:58 +08:00
int a[
sizeof(A)+
sizeof(B)+
sizeof(C)+
sizeof(D)+
sizeof(E)+
sizeof(F)+
sizeof(G)+
sizeof(H)+
sizeof(I)+
sizeof(AX)+
sizeof(BX)+
sizeof(CX)+
sizeof(DX)];