From 9f4dbff6669c8037f3b036bcf580d14f1a4f12a5 Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Mon, 24 Nov 2014 09:15:30 +0000 Subject: Vendor import of clang RELEASE_350/final tag r216957 (effectively, 3.5.0 release): https://llvm.org/svn/llvm-project/cfe/tags/RELEASE_350/final@216957 --- test/Layout/ms-x86-alias-avoidance-padding.cpp | 599 ++++++++++ test/Layout/ms-x86-aligned-tail-padding.cpp | 640 ++++++----- test/Layout/ms-x86-basic-layout.cpp | 1174 +++++++++++--------- test/Layout/ms-x86-bitfields-vbases.cpp | 160 +-- .../ms-x86-empty-base-after-base-with-vbptr.cpp | 336 +++--- test/Layout/ms-x86-empty-nonvirtual-bases.cpp | 180 +-- test/Layout/ms-x86-empty-virtual-base.cpp | 1079 +++++++++--------- test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp | 1154 ++++++++++--------- test/Layout/ms-x86-member-pointers.cpp | 80 ++ test/Layout/ms-x86-misalignedarray.cpp | 38 +- test/Layout/ms-x86-pack-and-align.cpp | 683 ++++++++++++ test/Layout/ms-x86-primary-bases.cpp | 454 ++++---- test/Layout/ms-x86-size-alignment-fail.cpp | 160 +-- test/Layout/ms-x86-vfvb-alignment.cpp | 580 +++++----- test/Layout/ms-x86-vfvb-sharing.cpp | 186 ++-- test/Layout/ms-x86-vtordisp.cpp | 473 ++++++-- 16 files changed, 4993 insertions(+), 2983 deletions(-) create mode 100644 test/Layout/ms-x86-alias-avoidance-padding.cpp create mode 100644 test/Layout/ms-x86-member-pointers.cpp create mode 100644 test/Layout/ms-x86-pack-and-align.cpp (limited to 'test/Layout') diff --git a/test/Layout/ms-x86-alias-avoidance-padding.cpp b/test/Layout/ms-x86-alias-avoidance-padding.cpp new file mode 100644 index 000000000000..e51bab387115 --- /dev/null +++ b/test/Layout/ms-x86-alias-avoidance-padding.cpp @@ -0,0 +1,599 @@ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ +// RUN: | FileCheck %s +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ +// RUN: | FileCheck %s -check-prefix CHECK-X64 + +extern "C" int printf(const char *fmt, ...); +__declspec(align(4096)) char buffer[4096]; + +struct AT {}; + +struct V : AT { + char c; + V() { + printf("V - this: %d\n", (int)((char*)this - buffer)); + } +}; + +struct AT0 { + union { struct { int a; AT t; } y; int b; } x; + char c; + AT0() { + printf("AT0 - this: %d\n", (int)((char*)this - buffer)); + } +}; + +struct AT1 : V { + int a; + AT1() { + printf("AT1 - this: %d\n", (int)((char*)this - buffer)); + } +}; + +struct AT2 { + AT0 t; + char AT2FieldName0; + AT2() { + printf("AT2 - this: %d\n", (int)((char*)this - buffer)); + printf("AT2 - Fiel: %d\n", (int)((char*)&AT2FieldName0 - buffer)); + } +}; + +struct AT3 : AT2, AT1 { + AT3() { + printf("AT3 - this: %d\n", (int)((char*)this - buffer)); + } +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct AT3 +// CHECK-NEXT: 0 | struct AT2 (base) +// CHECK-NEXT: 0 | struct AT0 t +// CHECK-NEXT: 0 | union AT0::(anonymous at {{.*}} x +// CHECK-NEXT: 0 | struct AT0::(anonymous at {{.*}} y +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | struct AT t (empty) +// CHECK: 0 | int b +// CHECK: 8 | char c +// CHECK: 12 | char AT2FieldName0 +// CHECK-NEXT: 20 | struct AT1 (base) +// CHECK-NEXT: 20 | struct V (base) +// CHECK-NEXT: 20 | struct AT (base) (empty) +// CHECK-NEXT: 20 | char c +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: | [sizeof=28, align=4 +// CHECK-NEXT: | nvsize=28, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AT3 +// CHECK-X64-NEXT: 0 | struct AT2 (base) +// CHECK-X64-NEXT: 0 | struct AT0 t +// CHECK-X64-NEXT: 0 | union AT0::(anonymous at {{.*}} x +// CHECK-X64-NEXT: 0 | struct AT0::(anonymous at {{.*}} y +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 4 | struct AT t (empty) +// CHECK-X64: 0 | int b +// CHECK-X64: 8 | char c +// CHECK-X64: 12 | char AT2FieldName0 +// CHECK-X64-NEXT: 20 | struct AT1 (base) +// CHECK-X64-NEXT: 20 | struct V (base) +// CHECK-X64-NEXT: 20 | struct AT (base) (empty) +// CHECK-X64-NEXT: 20 | char c +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: | [sizeof=28, align=4 +// CHECK-X64-NEXT: | nvsize=28, nvalign=4] + +struct BT0 { + BT0() { + printf("BT0 - this: %d\n", (int)((char*)this - buffer)); + } +}; + +struct BT2 : BT0 { + char BT2FieldName0; + BT2() { + printf("BT2 - this: %d\n", (int)((char*)this - buffer)); + printf("BT2 - Fiel: %d\n", (int)((char*)&BT2FieldName0 - buffer)); + } +}; + +struct BT3 : BT0, BT2 { + BT3() { + printf("BT3 - this: %d\n", (int)((char*)this - buffer)); + } +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct BT3 +// CHECK-NEXT: 0 | struct BT0 (base) (empty) +// CHECK-NEXT: 1 | struct BT2 (base) +// CHECK-NEXT: 1 | struct BT0 (base) (empty) +// CHECK-NEXT: 1 | char BT2FieldName0 +// CHECK-NEXT: | [sizeof=2, align=1 +// CHECK-NEXT: | nvsize=2, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct BT3 +// CHECK-X64-NEXT: 0 | struct BT0 (base) (empty) +// CHECK-X64-NEXT: 1 | struct BT2 (base) +// CHECK-X64-NEXT: 1 | struct BT0 (base) (empty) +// CHECK-X64-NEXT: 1 | char BT2FieldName0 +// CHECK-X64-NEXT: | [sizeof=2, align=1 +// CHECK-X64-NEXT: | nvsize=2, nvalign=1] + +struct T0 : AT { + T0() { + printf("T0 (this) : %d\n", (int)((char*)this - buffer)); + } +}; + +struct T1 : T0 { + char a; + T1() { + printf("T1 (this) : %d\n", (int)((char*)this - buffer)); + printf("T1 (fiel) : %d\n", (int)((char*)&a - buffer)); + } +}; + +struct T2 : AT { + char a; + T2() { + printf("T2 (this) : %d\n", (int)((char*)this - buffer)); + printf("T2 (fiel) : %d\n", (int)((char*)&a - buffer)); + } +}; + +struct __declspec(align(1)) T3 : virtual T1, virtual T2 { + T3() { + printf("T3 (this) : %d\n", (int)((char*)this - buffer)); + } +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct T3 +// CHECK-NEXT: 0 | (T3 vbtable pointer) +// CHECK-NEXT: 4 | struct T1 (virtual base) +// CHECK-NEXT: 4 | struct T0 (base) (empty) +// CHECK-NEXT: 4 | struct AT (base) (empty) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 12 | struct T2 (virtual base) +// CHECK-NEXT: 12 | struct AT (base) (empty) +// CHECK-NEXT: 12 | char a +// CHECK-NEXT: | [sizeof=16, 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: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct T3 +// CHECK-X64-NEXT: 0 | (T3 vbtable pointer) +// CHECK-X64-NEXT: 8 | struct T1 (virtual base) +// CHECK-X64-NEXT: 8 | struct T0 (base) (empty) +// CHECK-X64-NEXT: 8 | struct AT (base) (empty) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 16 | struct T2 (virtual base) +// CHECK-X64-NEXT: 16 | struct AT (base) (empty) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + +struct B {}; +struct C { int a; }; +struct D : B, virtual C { B b; }; +struct E : D, B {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | struct D (base) +// CHECK-NEXT: 4 | struct B (base) (empty) +// CHECK-NEXT: 0 | (D vbtable pointer) +// CHECK-NEXT: 4 | struct B b (empty) +// CHECK: 8 | struct B (base) (empty) +// CHECK-NEXT: 8 | struct C (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | struct D (base) +// CHECK-X64-NEXT: 8 | struct B (base) (empty) +// CHECK-X64-NEXT: 0 | (D vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B b (empty) +// CHECK-X64: 16 | struct B (base) (empty) +// CHECK-X64-NEXT: 16 | struct C (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] + +struct F : virtual D, virtual B {}; +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | (F vbtable pointer) +// CHECK-NEXT: 4 | struct C (virtual base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct D (virtual base) +// CHECK-NEXT: 12 | struct B (base) (empty) +// CHECK-NEXT: 8 | (D vbtable pointer) +// CHECK-NEXT: 12 | struct B b (empty) +// CHECK: 16 | struct B (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F +// CHECK-X64-NEXT: 0 | (F vbtable pointer) +// CHECK-X64-NEXT: 8 | struct C (virtual base) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct D (virtual base) +// CHECK-X64-NEXT: 24 | struct B (base) (empty) +// CHECK-X64-NEXT: 16 | (D vbtable pointer) +// CHECK-X64-NEXT: 24 | struct B b (empty) +// CHECK-X64: 32 | struct B (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=32, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + +struct JC0 { + JC0() { printf("JC0 : %d\n", (int)((char*)this - buffer)); } +}; +struct JC1 : JC0 { + virtual void f() {} + JC1() { printf("JC1 : %d\n", (int)((char*)this - buffer)); } +}; +struct JC2 : JC1 { + JC2() { printf("JC2 : %d\n", (int)((char*)this - buffer)); } +}; +struct JC4 : JC1, JC2 { + JC4() { printf("JC4 : %d\n", (int)((char*)this - buffer)); } +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct JC4 +// CHECK-NEXT: 0 | struct JC1 (primary base) +// CHECK-NEXT: 0 | (JC1 vftable pointer) +// CHECK-NEXT: 4 | struct JC0 (base) (empty) +// CHECK-NEXT: 8 | struct JC2 (base) +// CHECK-NEXT: 8 | struct JC1 (primary base) +// CHECK-NEXT: 8 | (JC1 vftable pointer) +// CHECK-NEXT: 12 | struct JC0 (base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct JC4 +// CHECK-X64-NEXT: 0 | struct JC1 (primary base) +// CHECK-X64-NEXT: 0 | (JC1 vftable pointer) +// CHECK-X64-NEXT: 8 | struct JC0 (base) (empty) +// CHECK-X64-NEXT: 16 | struct JC2 (base) +// CHECK-X64-NEXT: 16 | struct JC1 (primary base) +// CHECK-X64-NEXT: 16 | (JC1 vftable pointer) +// CHECK-X64-NEXT: 24 | struct JC0 (base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] + +struct RA {}; +struct RB { char c; }; +struct RV {}; +struct RW { char c; }; +struct RY { RY() { printf("%Id\n", (char*)this - buffer); } }; +struct RX0 : RB, RA {}; +struct RX1 : RA, RB {}; +struct RX2 : RA { char a; }; +struct RX3 : RA { RB a; }; +struct RX4 { RA a; char b; }; +struct RX5 { RA a; RB b; }; +struct RX6 : virtual RV { RB a; }; +struct RX7 : virtual RW { RA a; }; +struct RX8 : RA, virtual RW {}; + +struct RZ0 : RX0, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ0 +// CHECK-NEXT: 0 | struct RX0 (base) +// CHECK-NEXT: 0 | struct RB (base) +// CHECK-NEXT: 0 | char c +// CHECK-NEXT: 1 | struct RA (base) (empty) +// CHECK-NEXT: 2 | struct RY (base) (empty) +// CHECK-NEXT: | [sizeof=2, align=1 +// CHECK-NEXT: | nvsize=2, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RZ0 +// CHECK-X64-NEXT: 0 | struct RX0 (base) +// CHECK-X64-NEXT: 0 | struct RB (base) +// CHECK-X64-NEXT: 0 | char c +// CHECK-X64-NEXT: 1 | struct RA (base) (empty) +// CHECK-X64-NEXT: 2 | struct RY (base) (empty) +// CHECK-X64-NEXT: | [sizeof=2, align=1 +// CHECK-X64-NEXT: | nvsize=2, nvalign=1] + +struct RZ1 : RX1, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ1 +// CHECK-NEXT: 0 | struct RX1 (base) +// CHECK-NEXT: 0 | struct RA (base) (empty) +// CHECK-NEXT: 0 | struct RB (base) +// CHECK-NEXT: 0 | char c +// CHECK-NEXT: 1 | struct RY (base) (empty) +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=1, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RZ1 +// CHECK-X64-NEXT: 0 | struct RX1 (base) +// CHECK-X64-NEXT: 0 | struct RA (base) (empty) +// CHECK-X64-NEXT: 0 | struct RB (base) +// CHECK-X64-NEXT: 0 | char c +// CHECK-X64-NEXT: 1 | struct RY (base) (empty) +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=1, nvalign=1] + +struct RZ2 : RX2, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ2 +// CHECK-NEXT: 0 | struct RX2 (base) +// CHECK-NEXT: 0 | struct RA (base) (empty) +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 2 | struct RY (base) (empty) +// CHECK-NEXT: | [sizeof=2, align=1 +// CHECK-NEXT: | nvsize=2, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RZ2 +// CHECK-X64-NEXT: 0 | struct RX2 (base) +// CHECK-X64-NEXT: 0 | struct RA (base) (empty) +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 2 | struct RY (base) (empty) +// CHECK-X64-NEXT: | [sizeof=2, align=1 +// CHECK-X64-NEXT: | nvsize=2, nvalign=1] + +struct RZ3 : RX3, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ3 +// CHECK-NEXT: 0 | struct RX3 (base) +// CHECK-NEXT: 0 | struct RA (base) (empty) +// CHECK-NEXT: 0 | struct RB a +// CHECK-NEXT: 0 | char c +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=1, nvalign=1] +// CHECK-NEXT: 1 | struct RY (base) (empty) +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=1, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RZ3 +// CHECK-X64-NEXT: 0 | struct RX3 (base) +// CHECK-X64-NEXT: 0 | struct RA (base) (empty) +// CHECK-X64-NEXT: 0 | struct RB a +// CHECK-X64-NEXT: 0 | char c +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=1, nvalign=1] +// CHECK-X64-NEXT: 1 | struct RY (base) (empty) +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=1, nvalign=1] + +struct RZ4 : RX4, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ4 +// CHECK-NEXT: 0 | struct RX4 (base) +// CHECK-NEXT: 0 | struct RA a (empty) +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=0, nvalign=1] +// CHECK-NEXT: 1 | char b +// CHECK-NEXT: 3 | struct RY (base) (empty) +// CHECK-NEXT: | [sizeof=3, align=1 +// CHECK-NEXT: | nvsize=3, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RZ4 +// CHECK-X64-NEXT: 0 | struct RX4 (base) +// CHECK-X64-NEXT: 0 | struct RA a (empty) +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=0, nvalign=1] +// CHECK-X64-NEXT: 1 | char b +// CHECK-X64-NEXT: 3 | struct RY (base) (empty) +// CHECK-X64-NEXT: | [sizeof=3, align=1 +// CHECK-X64-NEXT: | nvsize=3, nvalign=1] + +struct RZ5 : RX5, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ5 +// CHECK-NEXT: 0 | struct RX5 (base) +// CHECK-NEXT: 0 | struct RA a (empty) +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=0, nvalign=1] +// CHECK-NEXT: 1 | struct RB b +// CHECK-NEXT: 1 | char c +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=1, nvalign=1] +// CHECK-NEXT: 2 | struct RY (base) (empty) +// CHECK-NEXT: | [sizeof=2, align=1 +// CHECK-NEXT: | nvsize=2, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RZ5 +// CHECK-X64-NEXT: 0 | struct RX5 (base) +// CHECK-X64-NEXT: 0 | struct RA a (empty) +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=0, nvalign=1] +// CHECK-X64-NEXT: 1 | struct RB b +// CHECK-X64-NEXT: 1 | char c +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=1, nvalign=1] +// CHECK-X64-NEXT: 2 | struct RY (base) (empty) +// CHECK-X64-NEXT: | [sizeof=2, align=1 +// CHECK-X64-NEXT: | nvsize=2, nvalign=1] + +struct RZ6 : RX6, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ6 +// CHECK-NEXT: 0 | struct RX6 (base) +// CHECK-NEXT: 0 | (RX6 vbtable pointer) +// CHECK-NEXT: 4 | struct RB a +// CHECK-NEXT: 4 | char c +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=1, nvalign=1] +// CHECK-NEXT: 9 | struct RY (base) (empty) +// CHECK-NEXT: 12 | struct RV (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, 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 RZ6 +// CHECK-X64-NEXT: 0 | struct RX6 (base) +// CHECK-X64-NEXT: 0 | (RX6 vbtable pointer) +// CHECK-X64-NEXT: 8 | struct RB a +// CHECK-X64-NEXT: 8 | char c +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=1, nvalign=1] +// CHECK-X64-NEXT: 17 | struct RY (base) (empty) +// CHECK-X64-NEXT: 24 | struct RV (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] + +struct RZ7 : RX7, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ7 +// CHECK-NEXT: 0 | struct RX7 (base) +// CHECK-NEXT: 0 | (RX7 vbtable pointer) +// CHECK-NEXT: 4 | struct RA a (empty) +// CHECK-NEXT: | [sizeof=1, align=1 +// CHECK-NEXT: | nvsize=0, nvalign=1] +// CHECK-NEXT: 8 | struct RY (base) (empty) +// CHECK-NEXT: 8 | struct RW (virtual base) +// CHECK-NEXT: 8 | char c +// CHECK-NEXT: | [sizeof=9, align=4 +// CHECK-NEXT: | nvsize=8, 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 RZ7 +// CHECK-X64-NEXT: 0 | struct RX7 (base) +// CHECK-X64-NEXT: 0 | (RX7 vbtable pointer) +// CHECK-X64-NEXT: 8 | struct RA a (empty) +// CHECK-X64-NEXT: | [sizeof=1, align=1 +// CHECK-X64-NEXT: | nvsize=0, nvalign=1] +// CHECK-X64-NEXT: 16 | struct RY (base) (empty) +// CHECK-X64-NEXT: 16 | struct RW (virtual base) +// CHECK-X64-NEXT: 16 | char c +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] + +struct RZ8 : RX8, RY {}; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RZ8 +// CHECK-NEXT: 0 | struct RX8 (base) +// CHECK-NEXT: 4 | struct RA (base) (empty) +// CHECK-NEXT: 0 | (RX8 vbtable pointer) +// CHECK-NEXT: 4 | struct RY (base) (empty) +// CHECK-NEXT: 4 | struct RW (virtual base) +// CHECK-NEXT: 4 | char c +// CHECK-NEXT: | [sizeof=5, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RZ8 +// CHECK-X64-NEXT: 0 | struct RX8 (base) +// CHECK-X64-NEXT: 8 | struct RA (base) (empty) +// CHECK-X64-NEXT: 0 | (RX8 vbtable pointer) +// CHECK-X64-NEXT: 8 | struct RY (base) (empty) +// CHECK-X64-NEXT: 8 | struct RW (virtual base) +// CHECK-X64-NEXT: 8 | char c +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + +struct JA {}; +struct JB {}; +struct JC : JA { virtual void f() {} }; +struct JD : virtual JB, virtual JC { virtual void f() {} JD() {} }; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct JD +// CHECK-NEXT: 0 | (JD vbtable pointer) +// CHECK-NEXT: 4 | struct JB (virtual base) (empty) +// CHECK-NEXT: 4 | (vtordisp for vbase JC) +// CHECK-NEXT: 8 | struct JC (virtual base) +// CHECK-NEXT: 8 | (JC vftable pointer) +// CHECK-NEXT: 12 | struct JA (base) (empty) +// CHECK-NEXT: | [sizeof=12, 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: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct JD +// CHECK-X64-NEXT: 0 | (JD vbtable pointer) +// CHECK-X64-NEXT: 8 | struct JB (virtual base) (empty) +// CHECK-X64-NEXT: 12 | (vtordisp for vbase JC) +// CHECK-X64-NEXT: 16 | struct JC (virtual base) +// CHECK-X64-NEXT: 16 | (JC vftable pointer) +// CHECK-X64-NEXT: 24 | struct JA (base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + +int a[ +sizeof(AT3) + +sizeof(BT3) + +sizeof(T3) + +sizeof(E) + +sizeof(F) + +sizeof(JC4) + +sizeof(RZ0) + +sizeof(RZ1) + +sizeof(RZ2) + +sizeof(RZ3) + +sizeof(RZ4) + +sizeof(RZ5) + +sizeof(RZ6) + +sizeof(RZ7) + +sizeof(RZ8) + +sizeof(JD) + +0]; diff --git a/test/Layout/ms-x86-aligned-tail-padding.cpp b/test/Layout/ms-x86-aligned-tail-padding.cpp index b9020f386c03..f919766546e4 100644 --- a/test/Layout/ms-x86-aligned-tail-padding.cpp +++ b/test/Layout/ms-x86-aligned-tail-padding.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -75,33 +75,41 @@ struct A : B1, B0, B2, virtual V { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | struct B1 (base) -// CHECK: 0 | int a -// CHECK: 4 | struct B0 (base) -// CHECK: 4 | int a -// CHECK: 16 | struct B2 (base) -// CHECK: 16 | int a -// CHECK: 32 | (A vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct V (virtual base) -// CHECK: 64 | char a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=64, nvalign=16] +// 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 // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct A -// CHECK-X64: 0 | struct B1 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 4 | struct B0 (base) -// CHECK-X64: 4 | int a -// CHECK-X64: 16 | struct B2 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | (A vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | struct V (virtual base) -// CHECK-X64: 48 | char a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// 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) +// 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] struct B : B2, B0, B1, virtual V { int a; @@ -109,33 +117,33 @@ struct B : B2, B0, B1, virtual V { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | struct B2 (base) -// CHECK: 0 | int a -// CHECK: 16 | struct B0 (base) -// CHECK: 16 | int a -// CHECK: 32 | struct B1 (base) -// CHECK: 32 | int a -// CHECK: 36 | (B vbtable pointer) -// CHECK: 52 | int a -// CHECK: 64 | struct V (virtual base) -// CHECK: 64 | char a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=64, nvalign=16] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | struct B2 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 16 | struct B0 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | struct B1 (base) -// CHECK-X64: 32 | int a -// CHECK-X64: 40 | (B vbtable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: 64 | struct V (virtual base) -// CHECK-X64: 64 | char a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=64, nvalign=16] +// 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) +// CHECK-X64-NEXT: 52 | 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] struct C : B1, B0, virtual V { int a; @@ -144,31 +152,31 @@ struct C : B1, B0, virtual V { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | struct B1 (base) -// CHECK: 0 | int a -// CHECK: 4 | struct B0 (base) -// CHECK: 4 | int a -// CHECK: 8 | (C vbtable pointer) -// CHECK: 24 | int a -// CHECK: 32 | long long a1 -// CHECK: 48 | struct V (virtual base) -// CHECK: 48 | char a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=48, nvalign=16] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | struct B1 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 4 | struct B0 (base) -// CHECK-X64: 4 | int a -// CHECK-X64: 8 | (C vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | long long a1 -// CHECK-X64: 32 | struct V (virtual base) -// CHECK-X64: 32 | char a -// CHECK-X64: | [sizeof=48, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// 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) +// 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] struct D : B2, B0, virtual V { int a; @@ -176,29 +184,29 @@ struct D : B2, B0, virtual V { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | struct B2 (base) -// CHECK: 0 | int a -// CHECK: 16 | struct B0 (base) -// CHECK: 16 | int a -// CHECK: 20 | (D vbtable pointer) -// CHECK: 36 | int a -// CHECK: 48 | struct V (virtual base) -// CHECK: 48 | char a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=48, nvalign=16] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | struct B2 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 16 | struct B0 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | (D vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct V (virtual base) -// CHECK-X64: 48 | char a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// 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) +// CHECK-X64-NEXT: 36 | int a +// 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] struct E : B3, B0, virtual V { int a; @@ -206,31 +214,33 @@ struct E : B3, B0, virtual V { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | struct B3 (base) -// CHECK: 0 | long long a1 -// CHECK: 8 | int a -// CHECK: 16 | struct B0 (base) -// CHECK: 16 | int a -// CHECK: 20 | (E vbtable pointer) -// CHECK: 36 | int a -// CHECK: 48 | struct V (virtual base) -// CHECK: 48 | char a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=48, nvalign=16] +// 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 // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct E -// CHECK-X64: 0 | struct B3 (base) -// CHECK-X64: 0 | long long a1 -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | (E vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct V (virtual base) -// CHECK-X64: 48 | char a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// 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) +// CHECK-X64-NEXT: 36 | int a +// 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] struct F : B0, virtual V1 { __declspec(align(16)) int a; @@ -239,29 +249,33 @@ struct F : B0, virtual V1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | struct B0 (base) -// CHECK: 0 | int a -// CHECK: 4 | (F vbtable pointer) -// CHECK: 32 | int a -// CHECK: 92 | (vtordisp for vbase V1) -// CHECK: 96 | struct V1 (virtual base) -// CHECK: 96 | (V1 vftable pointer) -// CHECK: 128 | struct A16 (base) (empty) -// CHECK: | [sizeof=128, align=32 -// CHECK: | nvsize=48, nvalign=16] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F -// CHECK-X64: 0 | struct B0 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (F vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 60 | (vtordisp for vbase V1) -// CHECK-X64: 64 | struct V1 (virtual base) -// CHECK-X64: 64 | (V1 vftable pointer) -// CHECK-X64: 96 | struct A16 (base) (empty) -// CHECK-X64: | [sizeof=96, align=32 -// CHECK-X64: | nvsize=32, nvalign=16] +// 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) +// 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] struct G : virtual V2, virtual V3 { int a; @@ -269,27 +283,31 @@ struct G : virtual V2, virtual V3 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct G -// CHECK: 0 | (G vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct V2 (virtual base) -// CHECK: 8 | long long a -// CHECK: 16 | int a1 -// CHECK: 24 | struct V3 (virtual base) -// CHECK: 24 | int a -// CHECK: | [sizeof=28, align=8 -// CHECK: | nvsize=8, nvalign=4] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct G -// CHECK-X64: 0 | (G vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct V2 (virtual base) -// CHECK-X64: 16 | long long a -// CHECK-X64: 24 | int a1 -// CHECK-X64: 32 | struct V3 (virtual base) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// 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] struct H { __declspec(align(16)) int a; @@ -298,17 +316,17 @@ struct H { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct H -// CHECK: 0 | int a -// CHECK: 4 | int b -// CHECK: | [sizeof=16, align=16 -// CHECK: | nvsize=16, nvalign=16] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct H -// CHECK-X64: 0 | int a -// CHECK-X64: 4 | int b -// CHECK-X64: | [sizeof=16, align=16 -// CHECK-X64: | nvsize=16, nvalign=16] +// 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] struct I { B2 a; @@ -317,19 +335,19 @@ struct I { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct I -// CHECK: 0 | struct B2 a -// CHECK: 0 | int a -// CHECK: 16 | int b -// CHECK: | [sizeof=32, align=16 -// CHECK: | nvsize=32, nvalign=16] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct I -// CHECK-X64: 0 | struct B2 a -// CHECK-X64: 0 | int a -// CHECK-X64: 16 | int b -// CHECK-X64: | [sizeof=32, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// 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] struct AX : B0X, virtual B2X, virtual B6X, virtual B3X { int a; @@ -339,41 +357,49 @@ struct AX : B0X, virtual B2X, virtual B6X, virtual B3X { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AX -// CHECK: 0 | (AX vftable pointer) -// CHECK: 16 | struct B0X (base) -// CHECK: 16 | int a -// CHECK: 20 | int a1 -// CHECK: 24 | (AX vbtable pointer) -// CHECK: 40 | int a -// CHECK: 48 | struct B2X (virtual base) -// CHECK: 48 | int a -// CHECK: 52 | struct B6X (virtual base) -// CHECK: 52 | int a -// CHECK: 76 | (vtordisp for vbase B3X) -// CHECK: 80 | struct B3X (virtual base) -// CHECK: 80 | (B3X vftable pointer) -// CHECK: 84 | int a -// CHECK: | [sizeof=96, align=16 -// CHECK: | nvsize=48, nvalign=16] +// 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 // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AX -// CHECK-X64: 0 | (AX vftable pointer) -// CHECK-X64: 16 | struct B0X (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 20 | int a1 -// CHECK-X64: 24 | (AX vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B2X (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: 52 | struct B6X (virtual base) -// CHECK-X64: 52 | int a -// CHECK-X64: 76 | (vtordisp for vbase B3X) -// CHECK-X64: 80 | struct B3X (virtual base) -// CHECK-X64: 80 | (B3X vftable pointer) -// CHECK-X64: 88 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// 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) +// CHECK-X64-NEXT: 40 | int a +// 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] struct BX : B4X, virtual B2X, virtual B6X, virtual B3X { int a; @@ -383,43 +409,47 @@ struct BX : B4X, virtual B2X, virtual B6X, virtual B3X { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct BX -// CHECK: 0 | (BX vftable pointer) -// CHECK: 16 | struct B4X (base) -// CHECK: 16 | struct A16X (base) (empty) -// CHECK: 16 | int a -// CHECK: 20 | int a1 -// CHECK: 32 | (BX vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct B2X (virtual base) -// CHECK: 64 | int a -// CHECK: 68 | struct B6X (virtual base) -// CHECK: 68 | int a -// CHECK: 92 | (vtordisp for vbase B3X) -// CHECK: 96 | struct B3X (virtual base) -// CHECK: 96 | (B3X vftable pointer) -// CHECK: 100 | int a -// CHECK: | [sizeof=112, align=16 -// CHECK: | nvsize=64, nvalign=16] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct BX -// CHECK-X64: 0 | (BX vftable pointer) -// CHECK-X64: 16 | struct B4X (base) -// CHECK-X64: 16 | struct A16X (base) (empty) -// CHECK-X64: 16 | int a -// CHECK-X64: 20 | int a1 -// CHECK-X64: 32 | (BX vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | struct B2X (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: 52 | struct B6X (virtual base) -// CHECK-X64: 52 | int a -// CHECK-X64: 76 | (vtordisp for vbase B3X) -// CHECK-X64: 80 | struct B3X (virtual base) -// CHECK-X64: 80 | (B3X vftable pointer) -// CHECK-X64: 88 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// 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) +// 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] struct CX : B5X, virtual B2X, virtual B6X, virtual B3X { int a; @@ -429,43 +459,45 @@ struct CX : B5X, virtual B2X, virtual B6X, virtual B3X { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct CX -// CHECK: 0 | (CX vftable pointer) -// CHECK: 16 | struct B5X (base) -// CHECK: 16 | (B5X vbtable pointer) -// CHECK: 20 | int a -// CHECK: 24 | int a1 -// CHECK: 28 | int a -// CHECK: 32 | struct A16X (virtual base) (empty) -// CHECK: 32 | struct B2X (virtual base) -// CHECK: 32 | int a -// CHECK: 36 | struct B6X (virtual base) -// CHECK: 36 | int a -// CHECK: 60 | (vtordisp for vbase B3X) -// CHECK: 64 | struct B3X (virtual base) -// CHECK: 64 | (B3X vftable pointer) -// CHECK: 68 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=32, nvalign=16] +// 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 // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct CX -// CHECK-X64: 0 | (CX vftable pointer) -// CHECK-X64: 16 | struct B5X (base) -// CHECK-X64: 16 | (B5X vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 28 | int a1 -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct A16X (virtual base) (empty) -// CHECK-X64: 48 | struct B2X (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: 52 | struct B6X (virtual base) -// CHECK-X64: 52 | int a -// CHECK-X64: 76 | (vtordisp for vbase B3X) -// CHECK-X64: 80 | struct B3X (virtual base) -// CHECK-X64: 80 | (B3X vftable pointer) -// CHECK-X64: 88 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// 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] struct __declspec(align(16)) DX { int a; @@ -474,17 +506,17 @@ struct __declspec(align(16)) DX { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct DX -// CHECK: 0 | (DX vftable pointer) -// CHECK: 4 | int a -// CHECK: | [sizeof=16, align=16 -// CHECK: | nvsize=8, nvalign=4] +// 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] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct DX -// CHECK-X64: 0 | (DX vftable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: | [sizeof=16, align=16 -// CHECK-X64: | nvsize=16, nvalign=8] +// 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] int a[ sizeof(A)+ diff --git a/test/Layout/ms-x86-basic-layout.cpp b/test/Layout/ms-x86-basic-layout.cpp index 86b3553b0ba0..b6ffeee7114a 100644 --- a/test/Layout/ms-x86-basic-layout.cpp +++ b/test/Layout/ms-x86-basic-layout.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -38,25 +38,29 @@ struct TestF0 : A4, virtual B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF0 -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF0 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct B4 (virtual base) -// CHECK: 12 | int a -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF0 -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF0 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B4 (virtual base) -// CHECK-X64: 24 | int a -// CHECK-X64: | [sizeof=32, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct TestF0 +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF0 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct B4 (virtual base) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=12, 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 TestF0 +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF0 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B4 (virtual base) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: | [sizeof=32, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct TestF1 : A4, virtual A16 { int a; @@ -64,25 +68,27 @@ struct TestF1 : A4, virtual A16 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF1 -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF1 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 16 | struct A16 (virtual base) -// CHECK: 16 | int a -// CHECK: | [sizeof=32, align=16 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF1 -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF1 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | struct A16 (virtual base) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=48, align=16 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct TestF1 +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF1 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 16 | struct A16 (virtual base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=32, align=16 +// CHECK-NEXT: | nvsize=12, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF1 +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF1 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | struct A16 (virtual base) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=48, align=16 +// CHECK-X64-NEXT: | nvsize=24, nvalign=16] struct TestF2 : A4, virtual C4 { int a; @@ -90,27 +96,29 @@ struct TestF2 : A4, virtual C4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF2 -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF2 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct C4 (virtual base) -// CHECK: 12 | (C4 vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF2 -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF2 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct C4 (virtual base) -// CHECK-X64: 24 | (C4 vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct TestF2 +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF2 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct C4 (virtual base) +// CHECK-NEXT: 12 | (C4 vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF2 +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF2 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct C4 (virtual base) +// CHECK-X64-NEXT: 24 | (C4 vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct TestF3 : A4, virtual C16 { int a; @@ -118,27 +126,29 @@ struct TestF3 : A4, virtual C16 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF3 -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF3 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 16 | struct C16 (virtual base) -// CHECK: 16 | (C16 vftable pointer) -// CHECK: 32 | int a -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF3 -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF3 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | struct C16 (virtual base) -// CHECK-X64: 32 | (C16 vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct TestF3 +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF3 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 16 | struct C16 (virtual base) +// CHECK-NEXT: 16 | (C16 vftable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=12, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF3 +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF3 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | struct C16 (virtual base) +// CHECK-X64-NEXT: 32 | (C16 vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=24, nvalign=16] struct TestF4 : TestF3, A4 { int a; @@ -146,35 +156,35 @@ struct TestF4 : TestF3, A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF4 -// CHECK: 0 | struct TestF3 (base) -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF3 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct A4 (base) -// CHECK: 12 | int a -// CHECK: 16 | int a -// CHECK: 32 | struct C16 (virtual base) -// CHECK: 32 | (C16 vftable pointer) -// CHECK: 48 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=32, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF4 -// CHECK-X64: 0 | struct TestF3 (base) -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF3 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct A4 (base) -// CHECK-X64: 24 | int a -// CHECK-X64: 28 | int a -// CHECK-X64: 32 | struct C16 (virtual base) -// CHECK-X64: 32 | (C16 vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// CHECK-NEXT: 0 | struct TestF4 +// CHECK-NEXT: 0 | struct TestF3 (base) +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF3 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct A4 (base) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | struct C16 (virtual base) +// CHECK-NEXT: 32 | (C16 vftable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF4 +// CHECK-X64-NEXT: 0 | struct TestF3 (base) +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF3 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct A4 (base) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 28 | int a +// CHECK-X64-NEXT: 32 | struct C16 (virtual base) +// CHECK-X64-NEXT: 32 | (C16 vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct TestF5 : TestF3, A4 { int a; @@ -183,37 +193,37 @@ struct TestF5 : TestF3, A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF5 -// CHECK: 0 | (TestF5 vftable pointer) -// CHECK: 16 | struct TestF3 (base) -// CHECK: 16 | struct A4 (base) -// CHECK: 16 | int a -// CHECK: 20 | (TestF3 vbtable pointer) -// CHECK: 24 | int a -// CHECK: 28 | struct A4 (base) -// CHECK: 28 | int a -// CHECK: 32 | int a -// CHECK: 48 | struct C16 (virtual base) -// CHECK: 48 | (C16 vftable pointer) -// CHECK: 64 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=48, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF5 -// CHECK-X64: 0 | (TestF5 vftable pointer) -// CHECK-X64: 16 | struct TestF3 (base) -// CHECK-X64: 16 | struct A4 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | (TestF3 vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 40 | struct A4 (base) -// CHECK-X64: 40 | int a -// CHECK-X64: 44 | int a -// CHECK-X64: 48 | struct C16 (virtual base) -// CHECK-X64: 48 | (C16 vftable pointer) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct TestF5 +// CHECK-NEXT: 0 | (TestF5 vftable pointer) +// CHECK-NEXT: 16 | struct TestF3 (base) +// CHECK-NEXT: 16 | struct A4 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | (TestF3 vbtable pointer) +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: 28 | struct A4 (base) +// CHECK-NEXT: 28 | int a +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 48 | struct C16 (virtual base) +// CHECK-NEXT: 48 | (C16 vftable pointer) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: | [sizeof=80, align=16 +// CHECK-NEXT: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF5 +// CHECK-X64-NEXT: 0 | (TestF5 vftable pointer) +// CHECK-X64-NEXT: 16 | struct TestF3 (base) +// CHECK-X64-NEXT: 16 | struct A4 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | (TestF3 vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 40 | struct A4 (base) +// CHECK-X64-NEXT: 40 | int a +// CHECK-X64-NEXT: 44 | int a +// CHECK-X64-NEXT: 48 | struct C16 (virtual base) +// CHECK-X64-NEXT: 48 | (C16 vftable pointer) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct TestF6 : TestF3, A4 { int a; @@ -222,37 +232,37 @@ struct TestF6 : TestF3, A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF6 -// CHECK: 0 | struct TestF3 (base) -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF3 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct A4 (base) -// CHECK: 12 | int a -// CHECK: 16 | int a -// CHECK: 44 | (vtordisp for vbase C16) -// CHECK: 48 | struct C16 (virtual base) -// CHECK: 48 | (C16 vftable pointer) -// CHECK: 64 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=32, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF6 -// CHECK-X64: 0 | struct TestF3 (base) -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF3 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct A4 (base) -// CHECK-X64: 24 | int a -// CHECK-X64: 28 | int a -// CHECK-X64: 44 | (vtordisp for vbase C16) -// CHECK-X64: 48 | struct C16 (virtual base) -// CHECK-X64: 48 | (C16 vftable pointer) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// CHECK-NEXT: 0 | struct TestF6 +// CHECK-NEXT: 0 | struct TestF3 (base) +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF3 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct A4 (base) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 44 | (vtordisp for vbase C16) +// CHECK-NEXT: 48 | struct C16 (virtual base) +// CHECK-NEXT: 48 | (C16 vftable pointer) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: | [sizeof=80, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF6 +// CHECK-X64-NEXT: 0 | struct TestF3 (base) +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF3 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct A4 (base) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 28 | int a +// CHECK-X64-NEXT: 44 | (vtordisp for vbase C16) +// CHECK-X64-NEXT: 48 | struct C16 (virtual base) +// CHECK-X64-NEXT: 48 | (C16 vftable pointer) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct TestF7 : A4, virtual C16 { int a; @@ -261,29 +271,29 @@ struct TestF7 : A4, virtual C16 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF7 -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF7 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 28 | (vtordisp for vbase C16) -// CHECK: 32 | struct C16 (virtual base) -// CHECK: 32 | (C16 vftable pointer) -// CHECK: 48 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF7 -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF7 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 44 | (vtordisp for vbase C16) -// CHECK-X64: 48 | struct C16 (virtual base) -// CHECK-X64: 48 | (C16 vftable pointer) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct TestF7 +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF7 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 28 | (vtordisp for vbase C16) +// CHECK-NEXT: 32 | struct C16 (virtual base) +// CHECK-NEXT: 32 | (C16 vftable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=12, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF7 +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF7 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 44 | (vtordisp for vbase C16) +// CHECK-X64-NEXT: 48 | struct C16 (virtual base) +// CHECK-X64-NEXT: 48 | (C16 vftable pointer) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=24, nvalign=16] struct TestF8 : TestF7, A4 { int a; @@ -292,37 +302,37 @@ struct TestF8 : TestF7, A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF8 -// CHECK: 0 | struct TestF7 (base) -// CHECK: 0 | struct A4 (base) -// CHECK: 0 | int a -// CHECK: 4 | (TestF7 vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct A4 (base) -// CHECK: 12 | int a -// CHECK: 16 | int a -// CHECK: 44 | (vtordisp for vbase C16) -// CHECK: 48 | struct C16 (virtual base) -// CHECK: 48 | (C16 vftable pointer) -// CHECK: 64 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=32, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF8 -// CHECK-X64: 0 | struct TestF7 (base) -// CHECK-X64: 0 | struct A4 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (TestF7 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct A4 (base) -// CHECK-X64: 24 | int a -// CHECK-X64: 28 | int a -// CHECK-X64: 44 | (vtordisp for vbase C16) -// CHECK-X64: 48 | struct C16 (virtual base) -// CHECK-X64: 48 | (C16 vftable pointer) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// CHECK-NEXT: 0 | struct TestF8 +// CHECK-NEXT: 0 | struct TestF7 (base) +// CHECK-NEXT: 0 | struct A4 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (TestF7 vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct A4 (base) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 44 | (vtordisp for vbase C16) +// CHECK-NEXT: 48 | struct C16 (virtual base) +// CHECK-NEXT: 48 | (C16 vftable pointer) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: | [sizeof=80, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF8 +// CHECK-X64-NEXT: 0 | struct TestF7 (base) +// CHECK-X64-NEXT: 0 | struct A4 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (TestF7 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct A4 (base) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 28 | int a +// CHECK-X64-NEXT: 44 | (vtordisp for vbase C16) +// CHECK-X64-NEXT: 48 | struct C16 (virtual base) +// CHECK-X64-NEXT: 48 | (C16 vftable pointer) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct TestF9 : A4, virtual C16 { int a; @@ -331,29 +341,29 @@ struct TestF9 : A4, virtual C16 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestF9 -// CHECK: 0 | (TestF9 vftable pointer) -// CHECK: 4 | struct A4 (base) -// CHECK: 4 | int a -// CHECK: 8 | (TestF9 vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | struct C16 (virtual base) -// CHECK: 16 | (C16 vftable pointer) -// CHECK: 32 | int a -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestF9 -// CHECK-X64: 0 | (TestF9 vftable pointer) -// CHECK-X64: 8 | struct A4 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (TestF9 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | struct C16 (virtual base) -// CHECK-X64: 32 | (C16 vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=32, nvalign=8] +// CHECK-NEXT: 0 | struct TestF9 +// CHECK-NEXT: 0 | (TestF9 vftable pointer) +// CHECK-NEXT: 4 | struct A4 (base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (TestF9 vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct C16 (virtual base) +// CHECK-NEXT: 16 | (C16 vftable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=16, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestF9 +// CHECK-X64-NEXT: 0 | (TestF9 vftable pointer) +// CHECK-X64-NEXT: 8 | struct A4 (base) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | (TestF9 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | struct C16 (virtual base) +// CHECK-X64-NEXT: 32 | (C16 vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct TestFA : TestF9, A4 { int a; @@ -362,37 +372,37 @@ struct TestFA : TestF9, A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestFA -// CHECK: 0 | struct TestF9 (primary base) -// CHECK: 0 | (TestF9 vftable pointer) -// CHECK: 4 | struct A4 (base) -// CHECK: 4 | int a -// CHECK: 8 | (TestF9 vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | struct A4 (base) -// CHECK: 16 | int a -// CHECK: 20 | int a -// CHECK: 32 | struct C16 (virtual base) -// CHECK: 32 | (C16 vftable pointer) -// CHECK: 48 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=32, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestFA -// CHECK-X64: 0 | struct TestF9 (primary base) -// CHECK-X64: 0 | (TestF9 vftable pointer) -// CHECK-X64: 8 | struct A4 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (TestF9 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | struct A4 (base) -// CHECK-X64: 32 | int a -// CHECK-X64: 36 | int a -// CHECK-X64: 48 | struct C16 (virtual base) -// CHECK-X64: 48 | (C16 vftable pointer) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct TestFA +// CHECK-NEXT: 0 | struct TestF9 (primary base) +// CHECK-NEXT: 0 | (TestF9 vftable pointer) +// CHECK-NEXT: 4 | struct A4 (base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (TestF9 vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct A4 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: 32 | struct C16 (virtual base) +// CHECK-NEXT: 32 | (C16 vftable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestFA +// CHECK-X64-NEXT: 0 | struct TestF9 (primary base) +// CHECK-X64-NEXT: 0 | (TestF9 vftable pointer) +// CHECK-X64-NEXT: 8 | struct A4 (base) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | (TestF9 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | struct A4 (base) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 36 | int a +// CHECK-X64-NEXT: 48 | struct C16 (virtual base) +// CHECK-X64-NEXT: 48 | (C16 vftable pointer) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct TestFB : A16, virtual C16 { int a; @@ -401,29 +411,29 @@ struct TestFB : A16, virtual C16 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestFB -// CHECK: 0 | (TestFB vftable pointer) -// CHECK: 16 | struct A16 (base) -// CHECK: 16 | int a -// CHECK: 32 | (TestFB vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct C16 (virtual base) -// CHECK: 64 | (C16 vftable pointer) -// CHECK: 80 | int a -// CHECK: | [sizeof=96, align=16 -// CHECK: | nvsize=64, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestFB -// CHECK-X64: 0 | (TestFB vftable pointer) -// CHECK-X64: 16 | struct A16 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | (TestFB vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | struct C16 (virtual base) -// CHECK-X64: 48 | (C16 vftable pointer) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct TestFB +// CHECK-NEXT: 0 | (TestFB vftable pointer) +// CHECK-NEXT: 16 | struct A16 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | (TestFB vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct C16 (virtual base) +// CHECK-NEXT: 64 | (C16 vftable pointer) +// CHECK-NEXT: 80 | int a +// CHECK-NEXT: | [sizeof=96, align=16 +// CHECK-NEXT: | nvsize=64, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestFB +// CHECK-X64-NEXT: 0 | (TestFB vftable pointer) +// CHECK-X64-NEXT: 16 | struct A16 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | (TestFB vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct C16 (virtual base) +// CHECK-X64-NEXT: 64 | (C16 vftable pointer) +// CHECK-X64-NEXT: 80 | int a +// CHECK-X64-NEXT: | [sizeof=96, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct TestFC : TestFB, A4 { int a; @@ -432,37 +442,37 @@ struct TestFC : TestFB, A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct TestFC -// CHECK: 0 | struct TestFB (primary base) -// CHECK: 0 | (TestFB vftable pointer) -// CHECK: 16 | struct A16 (base) -// CHECK: 16 | int a -// CHECK: 32 | (TestFB vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct A4 (base) -// CHECK: 64 | int a -// CHECK: 68 | int a -// CHECK: 80 | struct C16 (virtual base) -// CHECK: 80 | (C16 vftable pointer) -// CHECK: 96 | int a -// CHECK: | [sizeof=112, align=16 -// CHECK: | nvsize=80, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct TestFC -// CHECK-X64: 0 | struct TestFB (primary base) -// CHECK-X64: 0 | (TestFB vftable pointer) -// CHECK-X64: 16 | struct A16 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | (TestFB vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | struct A4 (base) -// CHECK-X64: 48 | int a -// CHECK-X64: 52 | int a -// CHECK-X64: 64 | struct C16 (virtual base) -// CHECK-X64: 64 | (C16 vftable pointer) -// CHECK-X64: 80 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=64, nvalign=16] +// CHECK-NEXT: 0 | struct TestFC +// CHECK-NEXT: 0 | struct TestFB (primary base) +// CHECK-NEXT: 0 | (TestFB vftable pointer) +// CHECK-NEXT: 16 | struct A16 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | (TestFB vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct A4 (base) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: 68 | int a +// CHECK-NEXT: 80 | struct C16 (virtual base) +// CHECK-NEXT: 80 | (C16 vftable pointer) +// CHECK-NEXT: 96 | int a +// CHECK-NEXT: | [sizeof=112, align=16 +// CHECK-NEXT: | nvsize=80, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct TestFC +// CHECK-X64-NEXT: 0 | struct TestFB (primary base) +// CHECK-X64-NEXT: 0 | (TestFB vftable pointer) +// CHECK-X64-NEXT: 16 | struct A16 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | (TestFB vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct A4 (base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 68 | int a +// CHECK-X64-NEXT: 80 | struct C16 (virtual base) +// CHECK-X64-NEXT: 80 | (C16 vftable pointer) +// CHECK-X64-NEXT: 96 | int a +// CHECK-X64-NEXT: | [sizeof=112, align=16 +// CHECK-X64-NEXT: | nvsize=80, nvalign=16] struct A16f { @@ -486,43 +496,51 @@ struct F0 : A4, B { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F0 -// CHECK: 0 | (F0 vftable pointer) -// CHECK: 16 | struct A4 (base) -// CHECK: 16 | int a -// CHECK: 32 | struct B (base) -// CHECK: 32 | struct A4 (base) -// CHECK: 32 | int a -// CHECK: 36 | struct Y (base) -// CHECK: 36 | char y -// CHECK: 48 | struct X (base) -// CHECK: 48 | (X vbtable pointer) -// CHECK: 52 | int a -// CHECK: 64 | int a -// CHECK: 80 | struct A16f (virtual base) -// CHECK: 80 | (A16f vftable pointer) -// CHECK: 96 | int a -// CHECK: | [sizeof=112, align=16 -// CHECK: | nvsize=80, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F0 -// CHECK-X64: 0 | (F0 vftable pointer) -// CHECK-X64: 8 | struct A4 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B (base) -// CHECK-X64: 16 | struct A4 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 20 | struct Y (base) -// CHECK-X64: 20 | char y -// CHECK-X64: 32 | struct X (base) -// CHECK-X64: 32 | (X vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | int a -// CHECK-X64: 64 | struct A16f (virtual base) -// CHECK-X64: 64 | (A16f vftable pointer) -// CHECK-X64: 80 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=64, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct F0 +// CHECK-NEXT: 0 | (F0 vftable pointer) +// CHECK-NEXT: 16 | struct A4 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | struct B (base) +// CHECK-NEXT: 32 | struct A4 (base) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 36 | struct Y (base) +// CHECK-NEXT: 36 | char y +// CHECK-NEXT: 48 | struct X (base) +// CHECK-NEXT: 48 | (X vbtable pointer) +// CHECK-NEXT: 52 | int a +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: 80 | struct A16f (virtual base) +// CHECK-NEXT: 80 | (A16f vftable pointer) +// CHECK-NEXT: 96 | int a +// CHECK-NEXT: | [sizeof=112, align=16 +// CHECK-NEXT: | nvsize=80, 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 +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F0 +// CHECK-X64-NEXT: 0 | (F0 vftable pointer) +// CHECK-X64-NEXT: 16 | struct A4 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | struct B (base) +// CHECK-X64-NEXT: 32 | struct A4 (base) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 36 | struct Y (base) +// CHECK-X64-NEXT: 36 | char y +// CHECK-X64-NEXT: 48 | struct X (base) +// CHECK-X64-NEXT: 48 | (X vbtable pointer) +// CHECK-X64-NEXT: 56 | int a +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 80 | struct A16f (virtual base) +// CHECK-X64-NEXT: 80 | (A16f vftable pointer) +// CHECK-X64-NEXT: 96 | int a +// CHECK-X64-NEXT: | [sizeof=112, align=16 +// CHECK-X64-NEXT: | nvsize=80, nvalign=16] struct F1 : B, A4 { int a; @@ -531,43 +549,43 @@ struct F1 : B, A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F1 -// CHECK: 0 | (F1 vftable pointer) -// CHECK: 16 | struct B (base) -// CHECK: 16 | struct A4 (base) -// CHECK: 16 | int a -// CHECK: 20 | struct Y (base) -// CHECK: 20 | char y -// CHECK: 32 | struct X (base) -// CHECK: 32 | (X vbtable pointer) -// CHECK: 36 | int a -// CHECK: 48 | struct A4 (base) -// CHECK: 48 | int a -// CHECK: 52 | int a -// CHECK: 64 | struct A16f (virtual base) -// CHECK: 64 | (A16f vftable pointer) -// CHECK: 80 | int a -// CHECK: | [sizeof=96, align=16 -// CHECK: | nvsize=64, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F1 -// CHECK-X64: 0 | (F1 vftable pointer) -// CHECK-X64: 16 | struct B (base) -// CHECK-X64: 16 | struct A4 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 20 | struct Y (base) -// CHECK-X64: 20 | char y -// CHECK-X64: 32 | struct X (base) -// CHECK-X64: 32 | (X vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | struct A4 (base) -// CHECK-X64: 48 | int a -// CHECK-X64: 52 | int a -// CHECK-X64: 64 | struct A16f (virtual base) -// CHECK-X64: 64 | (A16f vftable pointer) -// CHECK-X64: 80 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=64, nvalign=16] +// CHECK-NEXT: 0 | struct F1 +// CHECK-NEXT: 0 | (F1 vftable pointer) +// CHECK-NEXT: 16 | struct B (base) +// CHECK-NEXT: 16 | struct A4 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct Y (base) +// CHECK-NEXT: 20 | char y +// CHECK-NEXT: 32 | struct X (base) +// CHECK-NEXT: 32 | (X vbtable pointer) +// CHECK-NEXT: 36 | int a +// CHECK-NEXT: 48 | struct A4 (base) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 52 | int a +// CHECK-NEXT: 64 | struct A16f (virtual base) +// CHECK-NEXT: 64 | (A16f vftable pointer) +// CHECK-NEXT: 80 | int a +// CHECK-NEXT: | [sizeof=96, align=16 +// CHECK-NEXT: | nvsize=64, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F1 +// CHECK-X64-NEXT: 0 | (F1 vftable pointer) +// CHECK-X64-NEXT: 16 | struct B (base) +// CHECK-X64-NEXT: 16 | struct A4 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 20 | struct Y (base) +// CHECK-X64-NEXT: 20 | char y +// CHECK-X64-NEXT: 32 | struct X (base) +// CHECK-X64-NEXT: 32 | (X vbtable pointer) +// CHECK-X64-NEXT: 40 | int a +// CHECK-X64-NEXT: 48 | struct A4 (base) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 52 | int a +// CHECK-X64-NEXT: 64 | struct A16f (virtual base) +// CHECK-X64-NEXT: 64 | (A16f vftable pointer) +// CHECK-X64-NEXT: 80 | int a +// CHECK-X64-NEXT: | [sizeof=96, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct F2 : A4, virtual A16f { int a; @@ -576,29 +594,29 @@ struct F2 : A4, virtual A16f { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F2 -// CHECK: 0 | (F2 vftable pointer) -// CHECK: 4 | struct A4 (base) -// CHECK: 4 | int a -// CHECK: 8 | (F2 vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | struct A16f (virtual base) -// CHECK: 16 | (A16f vftable pointer) -// CHECK: 32 | int a -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F2 -// CHECK-X64: 0 | (F2 vftable pointer) -// CHECK-X64: 8 | struct A4 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (F2 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | struct A16f (virtual base) -// CHECK-X64: 32 | (A16f vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=32, nvalign=8] +// CHECK-NEXT: 0 | struct F2 +// CHECK-NEXT: 0 | (F2 vftable pointer) +// CHECK-NEXT: 4 | struct A4 (base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (F2 vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct A16f (virtual base) +// CHECK-NEXT: 16 | (A16f vftable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=16, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F2 +// CHECK-X64-NEXT: 0 | (F2 vftable pointer) +// CHECK-X64-NEXT: 8 | struct A4 (base) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | (F2 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | struct A16f (virtual base) +// CHECK-X64-NEXT: 32 | (A16f vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct F3 : A4, virtual A16f { __declspec(align(16)) int a; @@ -607,29 +625,29 @@ struct F3 : A4, virtual A16f { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F3 -// CHECK: 0 | (F3 vftable pointer) -// CHECK: 16 | struct A4 (base) -// CHECK: 16 | int a -// CHECK: 20 | (F3 vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct A16f (virtual base) -// CHECK: 64 | (A16f vftable pointer) -// CHECK: 80 | int a -// CHECK: | [sizeof=96, align=16 -// CHECK: | nvsize=64, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F3 -// CHECK-X64: 0 | (F3 vftable pointer) -// CHECK-X64: 8 | struct A4 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (F3 vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct A16f (virtual base) -// CHECK-X64: 48 | (A16f vftable pointer) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct F3 +// CHECK-NEXT: 0 | (F3 vftable pointer) +// CHECK-NEXT: 16 | struct A4 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | (F3 vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct A16f (virtual base) +// CHECK-NEXT: 64 | (A16f vftable pointer) +// CHECK-NEXT: 80 | int a +// CHECK-NEXT: | [sizeof=96, align=16 +// CHECK-NEXT: | nvsize=64, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F3 +// CHECK-X64-NEXT: 0 | (F3 vftable pointer) +// CHECK-X64-NEXT: 16 | struct A4 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | (F3 vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct A16f (virtual base) +// CHECK-X64-NEXT: 64 | (A16f vftable pointer) +// CHECK-X64-NEXT: 80 | int a +// CHECK-X64-NEXT: | [sizeof=96, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct F4 : A4, B { __declspec(align(16)) int a; @@ -638,43 +656,43 @@ struct F4 : A4, B { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F4 -// CHECK: 0 | (F4 vftable pointer) -// CHECK: 16 | struct A4 (base) -// CHECK: 16 | int a -// CHECK: 32 | struct B (base) -// CHECK: 32 | struct A4 (base) -// CHECK: 32 | int a -// CHECK: 36 | struct Y (base) -// CHECK: 36 | char y -// CHECK: 48 | struct X (base) -// CHECK: 48 | (X vbtable pointer) -// CHECK: 52 | int a -// CHECK: 64 | int a -// CHECK: 80 | struct A16f (virtual base) -// CHECK: 80 | (A16f vftable pointer) -// CHECK: 96 | int a -// CHECK: | [sizeof=112, align=16 -// CHECK: | nvsize=80, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F4 -// CHECK-X64: 0 | (F4 vftable pointer) -// CHECK-X64: 8 | struct A4 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B (base) -// CHECK-X64: 16 | struct A4 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 20 | struct Y (base) -// CHECK-X64: 20 | char y -// CHECK-X64: 32 | struct X (base) -// CHECK-X64: 32 | (X vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | int a -// CHECK-X64: 64 | struct A16f (virtual base) -// CHECK-X64: 64 | (A16f vftable pointer) -// CHECK-X64: 80 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=64, nvalign=16] +// CHECK-NEXT: 0 | struct F4 +// CHECK-NEXT: 0 | (F4 vftable pointer) +// CHECK-NEXT: 16 | struct A4 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | struct B (base) +// CHECK-NEXT: 32 | struct A4 (base) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 36 | struct Y (base) +// CHECK-NEXT: 36 | char y +// CHECK-NEXT: 48 | struct X (base) +// CHECK-NEXT: 48 | (X vbtable pointer) +// CHECK-NEXT: 52 | int a +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: 80 | struct A16f (virtual base) +// CHECK-NEXT: 80 | (A16f vftable pointer) +// CHECK-NEXT: 96 | int a +// CHECK-NEXT: | [sizeof=112, align=16 +// CHECK-NEXT: | nvsize=80, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F4 +// CHECK-X64-NEXT: 0 | (F4 vftable pointer) +// CHECK-X64-NEXT: 16 | struct A4 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | struct B (base) +// CHECK-X64-NEXT: 32 | struct A4 (base) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 36 | struct Y (base) +// CHECK-X64-NEXT: 36 | char y +// CHECK-X64-NEXT: 48 | struct X (base) +// CHECK-X64-NEXT: 48 | (X vbtable pointer) +// CHECK-X64-NEXT: 56 | int a +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 80 | struct A16f (virtual base) +// CHECK-X64-NEXT: 80 | (A16f vftable pointer) +// CHECK-X64-NEXT: 96 | int a +// CHECK-X64-NEXT: | [sizeof=112, align=16 +// CHECK-X64-NEXT: | nvsize=80, nvalign=16] struct F5 : A16f, virtual A4 { int a; @@ -683,27 +701,27 @@ struct F5 : A16f, virtual A4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F5 -// CHECK: 0 | struct A16f (primary base) -// CHECK: 0 | (A16f vftable pointer) -// CHECK: 16 | int a -// CHECK: 32 | (F5 vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct A4 (virtual base) -// CHECK: 64 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=64, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F5 -// CHECK-X64: 0 | struct A16f (primary base) -// CHECK-X64: 0 | (A16f vftable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | (F5 vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | struct A4 (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct F5 +// CHECK-NEXT: 0 | struct A16f (primary base) +// CHECK-NEXT: 0 | (A16f vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | (F5 vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct A4 (virtual base) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: | [sizeof=80, align=16 +// CHECK-NEXT: | nvsize=64, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F5 +// CHECK-X64-NEXT: 0 | struct A16f (primary base) +// CHECK-X64-NEXT: 0 | (A16f vftable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | (F5 vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct A4 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct F6 : virtual A16f, A4, virtual B { int a; @@ -712,45 +730,91 @@ struct F6 : virtual A16f, A4, virtual B { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F6 -// CHECK: 0 | (F6 vftable pointer) -// CHECK: 4 | struct A4 (base) -// CHECK: 4 | int a -// CHECK: 8 | (F6 vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | struct A16f (virtual base) -// CHECK: 16 | (A16f vftable pointer) -// CHECK: 32 | int a -// CHECK: 48 | struct B (virtual base) -// CHECK: 48 | struct A4 (base) -// CHECK: 48 | int a -// CHECK: 52 | struct Y (base) -// CHECK: 52 | char y -// CHECK: 64 | struct X (base) -// CHECK: 64 | (X vbtable pointer) -// CHECK: 68 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F6 -// CHECK-X64: 0 | (F6 vftable pointer) -// CHECK-X64: 8 | struct A4 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (F6 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | struct A16f (virtual base) -// CHECK-X64: 32 | (A16f vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: 64 | struct B (virtual base) -// CHECK-X64: 64 | struct A4 (base) -// CHECK-X64: 64 | int a -// CHECK-X64: 68 | struct Y (base) -// CHECK-X64: 68 | char y -// CHECK-X64: 80 | struct X (base) -// CHECK-X64: 80 | (X vbtable pointer) -// CHECK-X64: 88 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=32, nvalign=8] +// CHECK-NEXT: 0 | struct F6 +// CHECK-NEXT: 0 | (F6 vftable pointer) +// CHECK-NEXT: 4 | struct A4 (base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (F6 vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct A16f (virtual base) +// CHECK-NEXT: 16 | (A16f vftable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 48 | struct B (virtual base) +// CHECK-NEXT: 48 | struct A4 (base) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 52 | struct Y (base) +// CHECK-NEXT: 52 | char y +// CHECK-NEXT: 64 | struct X (base) +// CHECK-NEXT: 64 | (X vbtable pointer) +// CHECK-NEXT: 68 | int a +// CHECK-NEXT: | [sizeof=80, align=16 +// CHECK-NEXT: | nvsize=16, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F6 +// CHECK-X64-NEXT: 0 | (F6 vftable pointer) +// CHECK-X64-NEXT: 8 | struct A4 (base) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | (F6 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | struct A16f (virtual base) +// CHECK-X64-NEXT: 32 | (A16f vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct B (virtual base) +// CHECK-X64-NEXT: 64 | struct A4 (base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 68 | struct Y (base) +// CHECK-X64-NEXT: 68 | char y +// CHECK-X64-NEXT: 80 | struct X (base) +// CHECK-X64-NEXT: 80 | (X vbtable pointer) +// CHECK-X64-NEXT: 88 | int a +// CHECK-X64-NEXT: | [sizeof=96, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] + +struct ArrayFieldOfRecords { + A4 InlineElts[2]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct ArrayFieldOfRecords +// CHECK-NEXT: 0 | struct A4 [2] InlineElts +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct ArrayFieldOfRecords +// CHECK-X64-NEXT: 0 | struct A4 [2] InlineElts +// CHECK-X64-NEXT: | [sizeof=8, align=4 +// CHECK-X64-NEXT: | nvsize=8, nvalign=4] + +struct ArrayOfArrayFieldOfRecords { + A4 InlineElts[2][2]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct ArrayOfArrayFieldOfRecords +// CHECK-NEXT: 0 | struct A4 [2][2] InlineElts +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct ArrayOfArrayFieldOfRecords +// CHECK-X64-NEXT: 0 | struct A4 [2][2] InlineElts +// CHECK-X64-NEXT: | [sizeof=16, align=4 +// CHECK-X64-NEXT: | nvsize=16, nvalign=4] + +struct RecordArrayTypedef { + typedef A4 ArrayTy[2]; + ArrayTy InlineElts[2]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct RecordArrayTypedef +// CHECK-NEXT: 0 | ArrayTy [2] InlineElts +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RecordArrayTypedef +// CHECK-X64-NEXT: 0 | ArrayTy [2] InlineElts +// CHECK-X64-NEXT: | [sizeof=16, align=4 +// CHECK-X64-NEXT: | nvsize=16, nvalign=4] int a[ sizeof(TestF0)+ @@ -772,4 +836,8 @@ sizeof(F2)+ sizeof(F3)+ sizeof(F4)+ sizeof(F5)+ -sizeof(F6)]; +sizeof(F6)+ +sizeof(ArrayFieldOfRecords)+ +sizeof(ArrayOfArrayFieldOfRecords)+ +sizeof(RecordArrayTypedef)+ +0]; diff --git a/test/Layout/ms-x86-bitfields-vbases.cpp b/test/Layout/ms-x86-bitfields-vbases.cpp index e11ef67a6347..5b54596bbb83 100644 --- a/test/Layout/ms-x86-bitfields-vbases.cpp +++ b/test/Layout/ms-x86-bitfields-vbases.cpp @@ -1,84 +1,120 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 -struct B0 { }; - -struct A : virtual B0 { char a : 1; }; +struct B0 { int a; }; +struct B1 { int a; }; -// CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | (A vbtable pointer) -// CHECK: 4 | char a -// CHECK: 9 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=9, align=4 -// CHECK: | nvsize=8, nvalign=4] +struct A : virtual B0 { char a : 1; }; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | (A vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 8 | struct B0 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct A -// CHECK-X64: 0 | (A vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 17 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct A +// CHECK-X64-NEXT: 0 | (A vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] -struct B : virtual B0 { short a : 1; }; +struct B : virtual B0 { short a : 1; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | (B vbtable pointer) -// CHECK: 4 | short a -// CHECK: 10 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=10, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | (B vbtable pointer) +// CHECK-NEXT: 4 | short a +// CHECK-NEXT: 8 | struct B0 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | (B vbtable pointer) -// CHECK-X64: 8 | short a -// CHECK-X64: 18 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | (B vbtable pointer) +// CHECK-X64-NEXT: 8 | short a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] -struct C : virtual B0 { char a : 1; char : 0; }; +struct C : virtual B0 { char a : 1; char : 0; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | (C vbtable pointer) -// CHECK: 4 | char a -// CHECK: 5 | char -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | (C vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 5 | char +// CHECK-NEXT: 8 | struct B0 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | (C vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 9 | char -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | (C vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 9 | char +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] -struct D : virtual B0 { char a : 1; char b; }; +struct D : virtual B0 { char a : 1; char b; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | (D vbtable pointer) -// CHECK: 4 | char a -// CHECK: 5 | char b -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | (D vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 5 | char b +// CHECK-NEXT: 8 | struct B0 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | (D vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 9 | char b +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] + +struct E : virtual B0, virtual B1 { long long : 1; }; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | (E vbtable pointer) +// CHECK-NEXT: 8 | long long +// CHECK-NEXT: 16 | struct B0 (virtual base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B1 (virtual base) +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=16, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | (D vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 9 | char b -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | (E vbtable pointer) +// CHECK-X64-NEXT: 8 | long long +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 20 | struct B1 (virtual base) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] int a[ sizeof(A)+ sizeof(B)+ sizeof(C)+ -sizeof(D)]; +sizeof(D)+ +sizeof(E)]; diff --git a/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp b/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp index 293a61b96e64..224594ead408 100644 --- a/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp +++ b/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 @@ -14,197 +14,209 @@ struct Z : Y { }; struct A : X, W { char a; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | struct X (base) -// CHECK: 0 | (X vbtable pointer) -// CHECK: 4 | char a -// CHECK: 9 | struct W (base) (empty) -// CHECK: 9 | char a -// CHECK: 12 | struct V (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | struct X (base) +// CHECK-NEXT: 0 | (X vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 9 | struct W (base) (empty) +// CHECK-NEXT: 9 | char a +// CHECK-NEXT: 12 | struct V (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct A -// CHECK-X64: 0 | struct X (base) -// CHECK-X64: 0 | (X vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 17 | struct W (base) (empty) -// CHECK-X64: 17 | char a -// CHECK-X64: 24 | struct V (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct A +// CHECK-X64-NEXT: 0 | struct X (base) +// CHECK-X64-NEXT: 0 | (X vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 17 | struct W (base) (empty) +// CHECK-X64-NEXT: 17 | char a +// CHECK-X64-NEXT: 24 | struct V (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct B : X, U, W { char a; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | struct X (base) -// CHECK: 0 | (X vbtable pointer) -// CHECK: 4 | char a -// CHECK: 8 | struct U (base) -// CHECK: 8 | char a -// CHECK: 9 | struct W (base) (empty) -// CHECK: 9 | char a -// CHECK: 12 | struct V (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | struct X (base) +// CHECK-NEXT: 0 | (X vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 8 | struct U (base) +// CHECK-NEXT: 8 | char a +// CHECK-NEXT: 9 | struct W (base) (empty) +// CHECK-NEXT: 9 | char a +// CHECK-NEXT: 12 | struct V (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | struct X (base) -// CHECK-X64: 0 | (X vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 16 | struct U (base) -// CHECK-X64: 16 | char a -// CHECK-X64: 17 | struct W (base) (empty) -// CHECK-X64: 17 | char a -// CHECK-X64: 24 | struct V (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | struct X (base) +// CHECK-X64-NEXT: 0 | (X vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 16 | struct U (base) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 17 | struct W (base) (empty) +// CHECK-X64-NEXT: 17 | char a +// CHECK-X64-NEXT: 24 | struct V (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct C : X, V, W { char a; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | struct X (base) -// CHECK: 0 | (X vbtable pointer) -// CHECK: 4 | char a -// CHECK: 9 | struct V (base) (empty) -// CHECK: 10 | struct W (base) (empty) -// CHECK: 10 | char a -// CHECK: 12 | struct V (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | struct X (base) +// CHECK-NEXT: 0 | (X vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 9 | struct V (base) (empty) +// CHECK-NEXT: 10 | struct W (base) (empty) +// CHECK-NEXT: 10 | char a +// CHECK-NEXT: 12 | struct V (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | struct X (base) -// CHECK-X64: 0 | (X vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 17 | struct V (base) (empty) -// CHECK-X64: 18 | struct W (base) (empty) -// CHECK-X64: 18 | char a -// CHECK-X64: 24 | struct V (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | struct X (base) +// CHECK-X64-NEXT: 0 | (X vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 17 | struct V (base) (empty) +// CHECK-X64-NEXT: 18 | struct W (base) (empty) +// CHECK-X64-NEXT: 18 | char a +// CHECK-X64-NEXT: 24 | struct V (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct D : X, U, V, W { char a; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | struct X (base) -// CHECK: 0 | (X vbtable pointer) -// CHECK: 4 | char a -// CHECK: 8 | struct U (base) -// CHECK: 8 | char a -// CHECK: 9 | struct V (base) (empty) -// CHECK: 10 | struct W (base) (empty) -// CHECK: 10 | char a -// CHECK: 12 | struct V (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | struct X (base) +// CHECK-NEXT: 0 | (X vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 8 | struct U (base) +// CHECK-NEXT: 8 | char a +// CHECK-NEXT: 9 | struct V (base) (empty) +// CHECK-NEXT: 10 | struct W (base) (empty) +// CHECK-NEXT: 10 | char a +// CHECK-NEXT: 12 | struct V (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | struct X (base) -// CHECK-X64: 0 | (X vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 16 | struct U (base) -// CHECK-X64: 16 | char a -// CHECK-X64: 17 | struct V (base) (empty) -// CHECK-X64: 18 | struct W (base) (empty) -// CHECK-X64: 18 | char a -// CHECK-X64: 24 | struct V (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | struct X (base) +// CHECK-X64-NEXT: 0 | (X vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 16 | struct U (base) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 17 | struct V (base) (empty) +// CHECK-X64-NEXT: 18 | struct W (base) (empty) +// CHECK-X64-NEXT: 18 | char a +// CHECK-X64-NEXT: 24 | struct V (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct E : X, U, Y, V, W { char a; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | struct X (base) -// CHECK: 0 | (X vbtable pointer) -// CHECK: 4 | char a -// CHECK: 8 | struct U (base) -// CHECK: 8 | char a -// CHECK: 12 | struct Y (base) -// CHECK: 12 | (Y vbtable pointer) -// CHECK: 16 | char a -// CHECK: 21 | struct V (base) (empty) -// CHECK: 22 | struct W (base) (empty) -// CHECK: 22 | char a -// CHECK: 24 | struct V (virtual base) (empty) -// CHECK: | [sizeof=24, align=4 -// CHECK: | nvsize=24, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | struct X (base) +// CHECK-NEXT: 0 | (X vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 8 | struct U (base) +// CHECK-NEXT: 8 | char a +// CHECK-NEXT: 12 | struct Y (base) +// CHECK-NEXT: 12 | (Y vbtable pointer) +// CHECK-NEXT: 16 | char a +// CHECK-NEXT: 21 | struct V (base) (empty) +// CHECK-NEXT: 22 | struct W (base) (empty) +// CHECK-NEXT: 22 | char a +// CHECK-NEXT: 24 | struct V (virtual base) (empty) +// CHECK-NEXT: | [sizeof=24, align=4 +// CHECK-NEXT: | nvsize=24, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct E -// CHECK-X64: 0 | struct X (base) -// CHECK-X64: 0 | (X vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 16 | struct U (base) -// CHECK-X64: 16 | char a -// CHECK-X64: 24 | struct Y (base) -// CHECK-X64: 24 | (Y vbtable pointer) -// CHECK-X64: 32 | char a -// CHECK-X64: 41 | struct V (base) (empty) -// CHECK-X64: 42 | struct W (base) (empty) -// CHECK-X64: 42 | char a -// CHECK-X64: 48 | struct V (virtual base) (empty) -// CHECK-X64: | [sizeof=48, align=8 -// CHECK-X64: | nvsize=48, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | struct X (base) +// CHECK-X64-NEXT: 0 | (X vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 16 | struct U (base) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 24 | struct Y (base) +// CHECK-X64-NEXT: 24 | (Y vbtable pointer) +// CHECK-X64-NEXT: 32 | char a +// CHECK-X64-NEXT: 41 | struct V (base) (empty) +// CHECK-X64-NEXT: 42 | struct W (base) (empty) +// CHECK-X64-NEXT: 42 | char a +// CHECK-X64-NEXT: 48 | struct V (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=48, align=8 +// CHECK-X64-NEXT: | nvsize=48, nvalign=8] struct F : Z, W { char a; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | struct Z (base) -// CHECK: 0 | struct Y (base) -// CHECK: 0 | (Y vbtable pointer) -// CHECK: 4 | char a -// CHECK: 9 | struct W (base) (empty) -// CHECK: 9 | char a -// CHECK: 12 | struct V (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | struct Z (base) +// CHECK-NEXT: 0 | struct Y (base) +// CHECK-NEXT: 0 | (Y vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 9 | struct W (base) (empty) +// CHECK-NEXT: 9 | char a +// CHECK-NEXT: 12 | struct V (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F -// CHECK-X64: 0 | struct Z (base) -// CHECK-X64: 0 | struct Y (base) -// CHECK-X64: 0 | (Y vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 17 | struct W (base) (empty) -// CHECK-X64: 17 | char a -// CHECK-X64: 24 | struct V (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct F +// CHECK-X64-NEXT: 0 | struct Z (base) +// CHECK-X64-NEXT: 0 | struct Y (base) +// CHECK-X64-NEXT: 0 | (Y vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 17 | struct W (base) (empty) +// CHECK-X64-NEXT: 17 | char a +// CHECK-X64-NEXT: 24 | struct V (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct G : X, W, Y, V { char a; }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct G -// CHECK: 0 | struct X (base) -// CHECK: 0 | (X vbtable pointer) -// CHECK: 4 | char a -// CHECK: 9 | struct W (base) (empty) -// CHECK: 12 | struct Y (base) -// CHECK: 12 | (Y vbtable pointer) -// CHECK: 16 | char a -// CHECK: 21 | struct V (base) (empty) -// CHECK: 21 | char a -// CHECK: 24 | struct V (virtual base) (empty) -// CHECK: | [sizeof=24, align=4 -// CHECK: | nvsize=24, nvalign=4] +// CHECK-NEXT: 0 | struct G +// CHECK-NEXT: 0 | struct X (base) +// CHECK-NEXT: 0 | (X vbtable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 9 | struct W (base) (empty) +// CHECK-NEXT: 12 | struct Y (base) +// CHECK-NEXT: 12 | (Y vbtable pointer) +// CHECK-NEXT: 16 | char a +// CHECK-NEXT: 21 | struct V (base) (empty) +// CHECK-NEXT: 21 | char a +// CHECK-NEXT: 24 | struct V (virtual base) (empty) +// CHECK-NEXT: | [sizeof=24, align=4 +// CHECK-NEXT: | nvsize=24, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct G -// CHECK-X64: 0 | struct X (base) -// CHECK-X64: 0 | (X vbtable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: 17 | struct W (base) (empty) -// CHECK-X64: 24 | struct Y (base) -// CHECK-X64: 24 | (Y vbtable pointer) -// CHECK-X64: 32 | char a -// CHECK-X64: 41 | struct V (base) (empty) -// CHECK-X64: 41 | char a -// CHECK-X64: 48 | struct V (virtual base) (empty) -// CHECK-X64: | [sizeof=48, align=8 -// CHECK-X64: | nvsize=48, nvalign=8] +// CHECK-X64-NEXT: 0 | struct G +// CHECK-X64-NEXT: 0 | struct X (base) +// CHECK-X64-NEXT: 0 | (X vbtable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 17 | struct W (base) (empty) +// CHECK-X64-NEXT: 24 | struct Y (base) +// CHECK-X64-NEXT: 24 | (Y vbtable pointer) +// CHECK-X64-NEXT: 32 | char a +// CHECK-X64-NEXT: 41 | struct V (base) (empty) +// CHECK-X64-NEXT: 41 | char a +// CHECK-X64-NEXT: 48 | struct V (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=48, align=8 +// CHECK-X64-NEXT: | nvsize=48, nvalign=8] int a[ sizeof(A)+ diff --git a/test/Layout/ms-x86-empty-nonvirtual-bases.cpp b/test/Layout/ms-x86-empty-nonvirtual-bases.cpp index 01d10c9994f6..6ef14948e346 100644 --- a/test/Layout/ms-x86-empty-nonvirtual-bases.cpp +++ b/test/Layout/ms-x86-empty-nonvirtual-bases.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s extern "C" int printf(const char *fmt, ...); @@ -23,11 +23,12 @@ struct A : B0 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | struct B0 (base) (empty) -// CHECK: 0 | int a -// CHECK: | [sizeof=8, align=8 -// CHECK: | nvsize=8, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | struct B0 (base) (empty) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=8, nvalign=8] struct B : B0 { B0 b0; @@ -36,14 +37,14 @@ struct B : B0 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | struct B0 (base) (empty) -// CHECK: 0 | struct B0 b0 (empty) -// CHECK: | [sizeof=8, align=8 -// CHECK: | nvsize=0, nvalign=1] -// CHECK: 8 | int a -// CHECK: | [sizeof=16, align=8 -// CHECK: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | struct B0 (base) (empty) +// CHECK-NEXT: 0 | struct B0 b0 (empty) +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=0, nvalign=8] +// CHECK: 8 | int a +// CHECK-NEXT: | [sizeof=16, align=8 +// CHECK-NEXT: | nvsize=16, nvalign=8] struct C : B0, B1, B2, B3, B4 { int a; @@ -51,15 +52,19 @@ struct C : B0, B1, B2, B3, B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | struct B0 (base) (empty) -// CHECK: 8 | struct B1 (base) (empty) -// CHECK: 16 | struct B2 (base) (empty) -// CHECK: 24 | struct B3 (base) (empty) -// CHECK: 32 | struct B4 (base) (empty) -// CHECK: 32 | int a -// CHECK: | [sizeof=40, align=8 -// CHECK: | nvsize=40, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | struct B0 (base) (empty) +// CHECK-NEXT: 8 | struct B1 (base) (empty) +// CHECK-NEXT: 16 | struct B2 (base) (empty) +// CHECK-NEXT: 24 | struct B3 (base) (empty) +// CHECK-NEXT: 32 | struct B4 (base) (empty) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=40, align=8 +// CHECK-NEXT: | nvsize=40, nvalign=8] struct D { B0 b0; @@ -72,28 +77,31 @@ struct D { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | struct B0 b0 (empty) -// CHECK: | [sizeof=8, align=8 -// CHECK: | nvsize=0, nvalign=1] -// CHECK: 8 | struct C0 c0 -// CHECK: 8 | int a -// CHECK: | [sizeof=4, align=4 -// CHECK: | nvsize=4, nvalign=4] -// CHECK: 12 | struct C1 c1 -// CHECK: 12 | int a -// CHECK: | [sizeof=4, align=4 -// CHECK: | nvsize=4, nvalign=4] -// CHECK: 16 | struct C2 c2 -// CHECK: 16 | int a -// CHECK: | [sizeof=4, align=4 -// CHECK: | nvsize=4, nvalign=4] -// CHECK: 24 | struct B1 b1 (empty) -// CHECK: | [sizeof=8, align=8 -// CHECK: | nvsize=0, nvalign=1] -// CHECK: 32 | int a -// CHECK: | [sizeof=40, align=8 -// CHECK: | nvsize=40, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | struct B0 b0 (empty) +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=0, nvalign=8] +// CHECK: 8 | struct C0 c0 +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=4, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK: 12 | struct C1 c1 +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: | [sizeof=4, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK: 16 | struct C2 c2 +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=4, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK: 24 | struct B1 b1 (empty) +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=0, nvalign=8] +// CHECK: 32 | int a +// CHECK-NEXT: | [sizeof=40, align=8 +// CHECK-NEXT: | nvsize=40, nvalign=8] struct E : B0, C0, C1, C2, B1 { int a; @@ -101,18 +109,18 @@ struct E : B0, C0, C1, C2, B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | struct B0 (base) (empty) -// CHECK: 0 | struct C0 (base) -// CHECK: 0 | int a -// CHECK: 4 | struct C1 (base) -// CHECK: 4 | int a -// CHECK: 8 | struct C2 (base) -// CHECK: 8 | int a -// CHECK: 16 | struct B1 (base) (empty) -// CHECK: 16 | int a -// CHECK: | [sizeof=24, align=8 -// CHECK: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | struct B0 (base) (empty) +// CHECK-NEXT: 0 | struct C0 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | struct C1 (base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct C2 (base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 16 | struct B1 (base) (empty) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=24, nvalign=8] struct F : C0, B0, B1, C1 { int a; @@ -120,16 +128,16 @@ struct F : C0, B0, B1, C1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | struct C0 (base) -// CHECK: 0 | int a -// CHECK: 8 | struct B0 (base) (empty) -// CHECK: 16 | struct B1 (base) (empty) -// CHECK: 16 | struct C1 (base) -// CHECK: 16 | int a -// CHECK: 20 | int a -// CHECK: | [sizeof=24, align=8 -// CHECK: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | struct C0 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 8 | struct B0 (base) (empty) +// CHECK-NEXT: 16 | struct B1 (base) (empty) +// CHECK-NEXT: 16 | struct C1 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=24, nvalign=8] struct G : B0, B1, B2, B3, B4 { __declspec(align(32)) int a; @@ -137,15 +145,15 @@ struct G : B0, B1, B2, B3, B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct G -// CHECK: 0 | struct B0 (base) (empty) -// CHECK: 8 | struct B1 (base) (empty) -// CHECK: 16 | struct B2 (base) (empty) -// CHECK: 24 | struct B3 (base) (empty) -// CHECK: 32 | struct B4 (base) (empty) -// CHECK: 32 | int a -// CHECK: | [sizeof=64, align=32 -// CHECK: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct G +// CHECK-NEXT: 0 | struct B0 (base) (empty) +// CHECK-NEXT: 8 | struct B1 (base) (empty) +// CHECK-NEXT: 16 | struct B2 (base) (empty) +// CHECK-NEXT: 24 | struct B3 (base) (empty) +// CHECK-NEXT: 32 | struct B4 (base) (empty) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=64, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] struct __declspec(align(32)) H : B0, B1, B2, B3, B4 { int a; @@ -153,15 +161,15 @@ struct __declspec(align(32)) H : B0, B1, B2, B3, B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct H -// CHECK: 0 | struct B0 (base) (empty) -// CHECK: 8 | struct B1 (base) (empty) -// CHECK: 16 | struct B2 (base) (empty) -// CHECK: 24 | struct B3 (base) (empty) -// CHECK: 32 | struct B4 (base) (empty) -// CHECK: 32 | int a -// CHECK: | [sizeof=64, align=32 -// CHECK: | nvsize=40, nvalign=8] +// CHECK-NEXT: 0 | struct H +// CHECK-NEXT: 0 | struct B0 (base) (empty) +// CHECK-NEXT: 8 | struct B1 (base) (empty) +// CHECK-NEXT: 16 | struct B2 (base) (empty) +// CHECK-NEXT: 24 | struct B3 (base) (empty) +// CHECK-NEXT: 32 | struct B4 (base) (empty) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=64, align=32 +// CHECK-NEXT: | nvsize=40, nvalign=32] int a[ sizeof(A)+ diff --git a/test/Layout/ms-x86-empty-virtual-base.cpp b/test/Layout/ms-x86-empty-virtual-base.cpp index ef6f08175e7a..23e287acf93b 100644 --- a/test/Layout/ms-x86-empty-virtual-base.cpp +++ b/test/Layout/ms-x86-empty-virtual-base.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -27,19 +27,21 @@ struct A : virtual B0 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | (A vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=8, align=8 -// CHECK: | nvsize=8, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | (A vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=8, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct A -// CHECK-X64: 0 | (A vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct A +// CHECK-X64-NEXT: 0 | (A vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct B : virtual B0 { B0 b0; @@ -48,25 +50,25 @@ struct B : virtual B0 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | (B vbtable pointer) -// CHECK: 8 | struct B0 b0 (empty) -// CHECK: | [sizeof=8, align=8 -// CHECK: | nvsize=0, nvalign=1] -// CHECK: 16 | int a -// CHECK: 24 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=24, align=8 -// CHECK: | nvsize=24, nvalign=8] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | (B vbtable pointer) -// CHECK-X64: 8 | struct B0 b0 (empty) -// CHECK-X64: | [sizeof=8, align=8 -// CHECK-X64: | nvsize=0, nvalign=1] -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | (B vbtable pointer) +// CHECK-NEXT: 8 | struct B0 b0 (empty) +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=0, nvalign=8] +// CHECK: 16 | int a +// CHECK-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=24, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | (B vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B0 b0 (empty) +// CHECK-X64-NEXT: | [sizeof=8, align=8 +// CHECK-X64-NEXT: | nvsize=0, nvalign=8] +// CHECK-X64: 16 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct C : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 { int a; @@ -74,27 +76,35 @@ struct C : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | (C vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: 16 | struct B1 (virtual base) (empty) -// CHECK: 24 | struct B2 (virtual base) (empty) -// CHECK: 32 | struct B3 (virtual base) (empty) -// CHECK: 40 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=40, align=8 -// CHECK: | nvsize=8, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | (C vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: 24 | struct B1 (virtual base) (empty) -// CHECK-X64: 32 | struct B2 (virtual base) (empty) -// CHECK-X64: 40 | struct B3 (virtual base) (empty) -// CHECK-X64: 48 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=48, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | (C vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 16 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 24 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 32 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 40 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=40, align=8 +// CHECK-NEXT: | nvsize=8, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | (C vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 24 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 32 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 40 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 48 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=48, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct D { B0 b0; @@ -107,31 +117,37 @@ struct D { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | struct B0 b0 (empty) -// CHECK: 8 | struct C0 c0 -// CHECK: 8 | int a -// CHECK: 12 | struct C1 c1 -// CHECK: 12 | int a -// CHECK: 16 | struct C2 c2 -// CHECK: 16 | int a -// CHECK: 24 | struct B1 b1 (empty) -// CHECK: 32 | int a -// CHECK: | [sizeof=40, align=8 -// CHECK: | nvsize=40, nvalign=8] -// CHECK-64: *** Dumping AST Record Layout -// CHECK-64: 0 | struct D -// CHECK-64: 0 | struct B0 b0 (empty) -// CHECK-64: 8 | struct C0 c0 -// CHECK-64: 8 | int a -// CHECK-64: 12 | struct C1 c1 -// CHECK-64: 12 | int a -// CHECK-64: 16 | struct C2 c2 -// CHECK-64: 16 | int a -// CHECK-64: 24 | struct B1 b1 (empty) -// CHECK-64: 32 | int a -// CHECK-64: | [sizeof=40, align=8 -// CHECK-64: | nvsize=40, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | struct B0 b0 (empty) +// CHECK: 8 | struct C0 c0 +// CHECK-NEXT: 8 | int a +// CHECK: 12 | struct C1 c1 +// CHECK-NEXT: 12 | int a +// CHECK: 16 | struct C2 c2 +// CHECK-NEXT: 16 | int a +// CHECK: 24 | struct B1 b1 (empty) +// CHECK: 32 | int a +// CHECK-NEXT: | [sizeof=40, align=8 +// CHECK-NEXT: | nvsize=40, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | struct B0 b0 (empty) +// CHECK-X64: 8 | struct C0 c0 +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64: 12 | struct C1 c1 +// CHECK-X64-NEXT: 12 | int a +// CHECK-X64: 16 | struct C2 c2 +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64: 24 | struct B1 b1 (empty) +// CHECK-X64: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=40, nvalign=8] struct E : virtual B0, virtual C0, virtual C1, virtual C2, virtual B1 { int a; @@ -139,33 +155,33 @@ struct E : virtual B0, virtual C0, virtual C1, virtual C2, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | (E vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: 8 | struct C0 (virtual base) -// CHECK: 8 | int a -// CHECK: 12 | struct C1 (virtual base) -// CHECK: 12 | int a -// CHECK: 16 | struct C2 (virtual base) -// CHECK: 16 | int a -// CHECK: 24 | struct B1 (virtual base) (empty) -// CHECK: | [sizeof=24, align=8 -// CHECK: | nvsize=8, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct E -// CHECK-X64: 0 | (E vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: 16 | struct C0 (virtual base) -// CHECK-X64: 16 | int a -// CHECK-X64: 20 | struct C1 (virtual base) -// CHECK-X64: 20 | int a -// CHECK-X64: 24 | struct C2 (virtual base) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | struct B1 (virtual base) (empty) -// CHECK-X64: | [sizeof=32, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | (E vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 8 | struct C0 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct C1 (virtual base) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct C2 (virtual base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 24 | struct B1 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=8, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | (E vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 16 | struct C0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 20 | struct C1 (virtual base) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 24 | struct C2 (virtual base) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=32, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct F : virtual C0, virtual B0, virtual B1, virtual C1 { int a; @@ -173,29 +189,29 @@ struct F : virtual C0, virtual B0, virtual B1, virtual C1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | (F vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct C0 (virtual base) -// CHECK: 8 | int a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: 24 | struct B1 (virtual base) (empty) -// CHECK: 24 | struct C1 (virtual base) -// CHECK: 24 | int a -// CHECK: | [sizeof=32, align=8 -// CHECK: | nvsize=8, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F -// CHECK-X64: 0 | (F vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct C0 (virtual base) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: 32 | struct B1 (virtual base) (empty) -// CHECK-X64: 32 | struct C1 (virtual base) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | (F vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct C0 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 24 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 24 | struct C1 (virtual base) +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: | [sizeof=32, align=8 +// CHECK-NEXT: | nvsize=8, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F +// CHECK-X64-NEXT: 0 | (F vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct C0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 32 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 32 | struct C1 (virtual base) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct G : virtual C0, virtual B0, virtual B1, D0, virtual C1 { int a; @@ -204,33 +220,35 @@ struct G : virtual C0, virtual B0, virtual B1, D0, virtual C1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct G -// CHECK: 0 | struct D0 (primary base) -// CHECK: 0 | (D0 vftable pointer) -// CHECK: 4 | (G vbtable pointer) -// CHECK: 20 | int a -// CHECK: 32 | struct C0 (virtual base) -// CHECK: 32 | int a -// CHECK: 40 | struct B0 (virtual base) (empty) -// CHECK: 56 | struct B1 (virtual base) (empty) -// CHECK: 56 | struct C1 (virtual base) -// CHECK: 56 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=32, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct G -// CHECK-X64: 0 | struct D0 (primary base) -// CHECK-X64: 0 | (D0 vftable pointer) -// CHECK-X64: 8 | (G vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | struct C0 (virtual base) -// CHECK-X64: 32 | int a -// CHECK-X64: 40 | struct B0 (virtual base) (empty) -// CHECK-X64: 56 | struct B1 (virtual base) (empty) -// CHECK-X64: 56 | struct C1 (virtual base) -// CHECK-X64: 56 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct G +// CHECK-NEXT: 0 | struct D0 (primary base) +// CHECK-NEXT: 0 | (D0 vftable pointer) +// CHECK-NEXT: 4 | (G vbtable pointer) +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: 32 | struct C0 (virtual base) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 40 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 56 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 56 | struct C1 (virtual base) +// CHECK-NEXT: 56 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct G +// CHECK-X64-NEXT: 0 | struct D0 (primary base) +// CHECK-X64-NEXT: 0 | (D0 vftable pointer) +// CHECK-X64-NEXT: 8 | (G vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | struct C0 (virtual base) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 40 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 56 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 56 | struct C1 (virtual base) +// CHECK-X64-NEXT: 56 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct H : virtual C0, virtual B0, virtual B1, virtual D0, virtual C1 { int a; @@ -239,35 +257,35 @@ struct H : virtual C0, virtual B0, virtual B1, virtual D0, virtual C1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct H -// CHECK: 0 | (H vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct C0 (virtual base) -// CHECK: 8 | int a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: 24 | struct B1 (virtual base) (empty) -// CHECK: 44 | (vtordisp for vbase D0) -// CHECK: 48 | struct D0 (virtual base) -// CHECK: 48 | (D0 vftable pointer) -// CHECK: 52 | struct C1 (virtual base) -// CHECK: 52 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=8, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct H -// CHECK-X64: 0 | (H vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct C0 (virtual base) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: 40 | struct B1 (virtual base) (empty) -// CHECK-X64: 60 | (vtordisp for vbase D0) -// CHECK-X64: 64 | struct D0 (virtual base) -// CHECK-X64: 64 | (D0 vftable pointer) -// CHECK-X64: 72 | struct C1 (virtual base) -// CHECK-X64: 72 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct H +// CHECK-NEXT: 0 | (H vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct C0 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 24 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 44 | (vtordisp for vbase D0) +// CHECK-NEXT: 48 | struct D0 (virtual base) +// CHECK-NEXT: 48 | (D0 vftable pointer) +// CHECK-NEXT: 52 | struct C1 (virtual base) +// CHECK-NEXT: 52 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=8, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct H +// CHECK-X64-NEXT: 0 | (H vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct C0 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 40 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 60 | (vtordisp for vbase D0) +// CHECK-X64-NEXT: 64 | struct D0 (virtual base) +// CHECK-X64-NEXT: 64 | (D0 vftable pointer) +// CHECK-X64-NEXT: 72 | struct C1 (virtual base) +// CHECK-X64-NEXT: 72 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=16, nvalign=16] struct I : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -275,27 +293,27 @@ struct I : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct I -// CHECK: 0 | (I vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct B0 (virtual base) (empty) -// CHECK: 72 | struct B1 (virtual base) (empty) -// CHECK: 104 | struct B2 (virtual base) (empty) -// CHECK: 136 | struct B3 (virtual base) (empty) -// CHECK: 168 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=192, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct I -// CHECK-X64: 0 | (I vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct B0 (virtual base) (empty) -// CHECK-X64: 72 | struct B1 (virtual base) (empty) -// CHECK-X64: 104 | struct B2 (virtual base) (empty) -// CHECK-X64: 136 | struct B3 (virtual base) (empty) -// CHECK-X64: 168 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=192, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct I +// CHECK-NEXT: 0 | (I vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=192, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct I +// CHECK-X64-NEXT: 0 | (I vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=192, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct __declspec(align(32)) J : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 { int a; @@ -303,27 +321,27 @@ struct __declspec(align(32)) J : virtual B0, virtual B1, virtual B2, virtual B3, }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct J -// CHECK: 0 | (J vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: 40 | struct B1 (virtual base) (empty) -// CHECK: 72 | struct B2 (virtual base) (empty) -// CHECK: 104 | struct B3 (virtual base) (empty) -// CHECK: 136 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=160, align=32 -// CHECK: | nvsize=8, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct J -// CHECK-X64: 0 | (J vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: 40 | struct B1 (virtual base) (empty) -// CHECK-X64: 72 | struct B2 (virtual base) (empty) -// CHECK-X64: 104 | struct B3 (virtual base) (empty) -// CHECK-X64: 136 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=160, align=32 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct J +// CHECK-NEXT: 0 | (J vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 40 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 72 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=160, align=32 +// CHECK-NEXT: | nvsize=8, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct J +// CHECK-X64-NEXT: 0 | (J vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 40 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 72 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=160, align=32 +// CHECK-X64-NEXT: | nvsize=16, nvalign=32] struct K : virtual D1, virtual B1, virtual B2, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -331,27 +349,29 @@ struct K : virtual D1, virtual B1, virtual B2, virtual B3, virtual B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct K -// CHECK: 0 | (K vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct D1 (virtual base) (empty) -// CHECK: 72 | struct B1 (virtual base) (empty) -// CHECK: 104 | struct B2 (virtual base) (empty) -// CHECK: 136 | struct B3 (virtual base) (empty) -// CHECK: 168 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=192, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct K -// CHECK-X64: 0 | (K vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct D1 (virtual base) (empty) -// CHECK-X64: 72 | struct B1 (virtual base) (empty) -// CHECK-X64: 104 | struct B2 (virtual base) (empty) -// CHECK-X64: 136 | struct B3 (virtual base) (empty) -// CHECK-X64: 168 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=192, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct K +// CHECK-NEXT: 0 | (K vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct D1 (virtual base) (empty) +// CHECK-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=192, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct K +// CHECK-X64-NEXT: 0 | (K vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=192, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct L : virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -359,27 +379,27 @@ struct L : virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct L -// CHECK: 0 | (L vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct B1 (virtual base) (empty) -// CHECK: 68 | struct D1 (virtual base) (empty) -// CHECK: 104 | struct B2 (virtual base) (empty) -// CHECK: 136 | struct B3 (virtual base) (empty) -// CHECK: 168 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=192, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct L -// CHECK-X64: 0 | (L vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct B1 (virtual base) (empty) -// CHECK-X64: 68 | struct D1 (virtual base) (empty) -// CHECK-X64: 104 | struct B2 (virtual base) (empty) -// CHECK-X64: 136 | struct B3 (virtual base) (empty) -// CHECK-X64: 168 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=192, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct L +// CHECK-NEXT: 0 | (L vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 68 | struct D1 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=192, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct L +// CHECK-X64-NEXT: 0 | (L vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 68 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=192, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct M : virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -387,27 +407,27 @@ struct M : virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct M -// CHECK: 0 | (M vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct B1 (virtual base) (empty) -// CHECK: 72 | struct B2 (virtual base) (empty) -// CHECK: 100 | struct D1 (virtual base) (empty) -// CHECK: 136 | struct B3 (virtual base) (empty) -// CHECK: 168 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=192, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct M -// CHECK-X64: 0 | (M vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct B1 (virtual base) (empty) -// CHECK-X64: 72 | struct B2 (virtual base) (empty) -// CHECK-X64: 100 | struct D1 (virtual base) (empty) -// CHECK-X64: 136 | struct B3 (virtual base) (empty) -// CHECK-X64: 168 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=192, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct M +// CHECK-NEXT: 0 | (M vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 72 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 100 | struct D1 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=192, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct M +// CHECK-X64-NEXT: 0 | (M vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 72 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 100 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=192, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct N : virtual C0, virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -415,31 +435,31 @@ struct N : virtual C0, virtual B1, virtual D1, virtual B2, virtual B3, virtual B }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct N -// CHECK: 0 | (N vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct C0 (virtual base) -// CHECK: 64 | int a -// CHECK: 72 | struct B1 (virtual base) (empty) -// CHECK: 100 | struct D1 (virtual base) (empty) -// CHECK: 136 | struct B2 (virtual base) (empty) -// CHECK: 168 | struct B3 (virtual base) (empty) -// CHECK: 200 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=224, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct N -// CHECK-X64: 0 | (N vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct C0 (virtual base) -// CHECK-X64: 64 | int a -// CHECK-X64: 72 | struct B1 (virtual base) (empty) -// CHECK-X64: 100 | struct D1 (virtual base) (empty) -// CHECK-X64: 136 | struct B2 (virtual base) (empty) -// CHECK-X64: 168 | struct B3 (virtual base) (empty) -// CHECK-X64: 200 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=224, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct N +// CHECK-NEXT: 0 | (N vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct C0 (virtual base) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 100 | struct D1 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 200 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=224, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct N +// CHECK-X64-NEXT: 0 | (N vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct C0 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 100 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 200 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=224, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct O : virtual C0, virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -447,31 +467,31 @@ struct O : virtual C0, virtual B1, virtual B2, virtual D1, virtual B3, virtual B }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct O -// CHECK: 0 | (O vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct C0 (virtual base) -// CHECK: 64 | int a -// CHECK: 72 | struct B1 (virtual base) (empty) -// CHECK: 104 | struct B2 (virtual base) (empty) -// CHECK: 132 | struct D1 (virtual base) (empty) -// CHECK: 168 | struct B3 (virtual base) (empty) -// CHECK: 200 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=224, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct O -// CHECK-X64: 0 | (O vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct C0 (virtual base) -// CHECK-X64: 64 | int a -// CHECK-X64: 72 | struct B1 (virtual base) (empty) -// CHECK-X64: 104 | struct B2 (virtual base) (empty) -// CHECK-X64: 132 | struct D1 (virtual base) (empty) -// CHECK-X64: 168 | struct B3 (virtual base) (empty) -// CHECK-X64: 200 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=224, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct O +// CHECK-NEXT: 0 | (O vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct C0 (virtual base) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 132 | struct D1 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 200 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=224, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct O +// CHECK-X64-NEXT: 0 | (O vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct C0 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 132 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 200 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=224, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct P : virtual B1, virtual C0, virtual D1, virtual B2, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -479,31 +499,31 @@ struct P : virtual B1, virtual C0, virtual D1, virtual B2, virtual B3, virtual B }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct P -// CHECK: 0 | (P vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct B1 (virtual base) (empty) -// CHECK: 64 | struct C0 (virtual base) -// CHECK: 64 | int a -// CHECK: 68 | struct D1 (virtual base) (empty) -// CHECK: 104 | struct B2 (virtual base) (empty) -// CHECK: 136 | struct B3 (virtual base) (empty) -// CHECK: 168 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=192, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct P -// CHECK-X64: 0 | (P vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct B1 (virtual base) (empty) -// CHECK-X64: 64 | struct C0 (virtual base) -// CHECK-X64: 64 | int a -// CHECK-X64: 68 | struct D1 (virtual base) (empty) -// CHECK-X64: 104 | struct B2 (virtual base) (empty) -// CHECK-X64: 136 | struct B3 (virtual base) (empty) -// CHECK-X64: 168 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=192, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct P +// CHECK-NEXT: 0 | (P vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 64 | struct C0 (virtual base) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: 68 | struct D1 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=192, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct P +// CHECK-X64-NEXT: 0 | (P vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 64 | struct C0 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 68 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=192, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct Q : virtual B1, virtual C0, virtual B2, virtual D1, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -511,31 +531,31 @@ struct Q : virtual B1, virtual C0, virtual B2, virtual D1, virtual B3, virtual B }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct Q -// CHECK: 0 | (Q vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct B1 (virtual base) (empty) -// CHECK: 64 | struct C0 (virtual base) -// CHECK: 64 | int a -// CHECK: 72 | struct B2 (virtual base) (empty) -// CHECK: 100 | struct D1 (virtual base) (empty) -// CHECK: 136 | struct B3 (virtual base) (empty) -// CHECK: 168 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=192, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct Q -// CHECK-X64: 0 | (Q vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct B1 (virtual base) (empty) -// CHECK-X64: 64 | struct C0 (virtual base) -// CHECK-X64: 64 | int a -// CHECK-X64: 72 | struct B2 (virtual base) (empty) -// CHECK-X64: 100 | struct D1 (virtual base) (empty) -// CHECK-X64: 136 | struct B3 (virtual base) (empty) -// CHECK-X64: 168 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=192, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct Q +// CHECK-NEXT: 0 | (Q vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 64 | struct C0 (virtual base) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: 72 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 100 | struct D1 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=192, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct Q +// CHECK-X64-NEXT: 0 | (Q vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 64 | struct C0 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: 72 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 100 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 168 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=192, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct R : virtual B0, virtual B1, virtual B2, virtual C0, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -543,31 +563,31 @@ struct R : virtual B0, virtual B1, virtual B2, virtual C0, virtual B3, virtual B }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct R -// CHECK: 0 | (R vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct B0 (virtual base) (empty) -// CHECK: 72 | struct B1 (virtual base) (empty) -// CHECK: 104 | struct B2 (virtual base) (empty) -// CHECK: 104 | struct C0 (virtual base) -// CHECK: 104 | int a -// CHECK: 112 | struct B3 (virtual base) (empty) -// CHECK: 136 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=160, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct R -// CHECK-X64: 0 | (R vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct B0 (virtual base) (empty) -// CHECK-X64: 72 | struct B1 (virtual base) (empty) -// CHECK-X64: 104 | struct B2 (virtual base) (empty) -// CHECK-X64: 104 | struct C0 (virtual base) -// CHECK-X64: 104 | int a -// CHECK-X64: 112 | struct B3 (virtual base) (empty) -// CHECK-X64: 136 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=160, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct R +// CHECK-NEXT: 0 | (R vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 104 | struct C0 (virtual base) +// CHECK-NEXT: 104 | int a +// CHECK-NEXT: 112 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=160, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct R +// CHECK-X64-NEXT: 0 | (R vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct C0 (virtual base) +// CHECK-X64-NEXT: 104 | int a +// CHECK-X64-NEXT: 112 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=160, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct S : virtual B0, virtual B1, virtual C0, virtual B2, virtual B3, virtual B4 { __declspec(align(32)) int a; @@ -575,31 +595,31 @@ struct S : virtual B0, virtual B1, virtual C0, virtual B2, virtual B3, virtual B }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct S -// CHECK: 0 | (S vbtable pointer) -// CHECK: 32 | int a -// CHECK: 64 | struct B0 (virtual base) (empty) -// CHECK: 72 | struct B1 (virtual base) (empty) -// CHECK: 72 | struct C0 (virtual base) -// CHECK: 72 | int a -// CHECK: 80 | struct B2 (virtual base) (empty) -// CHECK: 104 | struct B3 (virtual base) (empty) -// CHECK: 136 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=160, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct S -// CHECK-X64: 0 | (S vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 64 | struct B0 (virtual base) (empty) -// CHECK-X64: 72 | struct B1 (virtual base) (empty) -// CHECK-X64: 72 | struct C0 (virtual base) -// CHECK-X64: 72 | int a -// CHECK-X64: 80 | struct B2 (virtual base) (empty) -// CHECK-X64: 104 | struct B3 (virtual base) (empty) -// CHECK-X64: 136 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=160, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK-NEXT: 0 | struct S +// CHECK-NEXT: 0 | (S vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 64 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 72 | struct C0 (virtual base) +// CHECK-NEXT: 72 | int a +// CHECK-NEXT: 80 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 136 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=160, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct S +// CHECK-X64-NEXT: 0 | (S vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 64 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 72 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 72 | struct C0 (virtual base) +// CHECK-X64-NEXT: 72 | int a +// CHECK-X64-NEXT: 80 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 136 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=160, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct T : virtual B0, virtual B1, virtual C0, virtual D2, virtual B2, virtual B3, virtual B4 { __declspec(align(16)) int a; @@ -607,35 +627,37 @@ struct T : virtual B0, virtual B1, virtual C0, virtual D2, virtual B2, virtual B }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct T -// CHECK: 0 | (T vbtable pointer) -// CHECK: 16 | int a -// CHECK: 32 | struct B0 (virtual base) (empty) -// CHECK: 40 | struct B1 (virtual base) (empty) -// CHECK: 40 | struct C0 (virtual base) -// CHECK: 40 | int a -// CHECK: 44 | struct D2 (virtual base) -// CHECK: 44 | int [8] a -// CHECK: 80 | struct B2 (virtual base) (empty) -// CHECK: 88 | struct B3 (virtual base) (empty) -// CHECK: 104 | struct B4 (virtual base) (empty) -// CHECK: | [sizeof=112, align=16 -// CHECK: | nvsize=32, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct T -// CHECK-X64: 0 | (T vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | struct B0 (virtual base) (empty) -// CHECK-X64: 40 | struct B1 (virtual base) (empty) -// CHECK-X64: 40 | struct C0 (virtual base) -// CHECK-X64: 40 | int a -// CHECK-X64: 44 | struct D2 (virtual base) -// CHECK-X64: 44 | int [8] a -// CHECK-X64: 80 | struct B2 (virtual base) (empty) -// CHECK-X64: 88 | struct B3 (virtual base) (empty) -// CHECK-X64: 104 | struct B4 (virtual base) (empty) -// CHECK-X64: | [sizeof=112, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct T +// CHECK-NEXT: 0 | (T vbtable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 40 | struct B1 (virtual base) (empty) +// CHECK-NEXT: 40 | struct C0 (virtual base) +// CHECK-NEXT: 40 | int a +// CHECK-NEXT: 44 | struct D2 (virtual base) +// CHECK-NEXT: 44 | int [8] a +// CHECK-NEXT: 80 | struct B2 (virtual base) (empty) +// CHECK-NEXT: 88 | struct B3 (virtual base) (empty) +// CHECK-NEXT: 104 | struct B4 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=112, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct T +// CHECK-X64-NEXT: 0 | (T vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 40 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: 40 | struct C0 (virtual base) +// CHECK-X64-NEXT: 40 | int a +// CHECK-X64-NEXT: 44 | struct D2 (virtual base) +// CHECK-X64-NEXT: 44 | int [8] a +// CHECK-X64-NEXT: 80 | struct B2 (virtual base) (empty) +// CHECK-X64-NEXT: 88 | struct B3 (virtual base) (empty) +// CHECK-X64-NEXT: 104 | struct B4 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=112, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct __declspec(align(32)) U : virtual B0, virtual B1 { int a; @@ -643,21 +665,21 @@ struct __declspec(align(32)) U : virtual B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct U -// CHECK: 0 | (U vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: 40 | struct B1 (virtual base) (empty) -// CHECK: | [sizeof=64, align=32 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct U +// CHECK-NEXT: 0 | (U vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0 (virtual base) (empty) +// CHECK-NEXT: 40 | struct B1 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=64, align=32 +// CHECK-NEXT: | nvsize=8, nvalign=32] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct U -// CHECK-X64: 0 | (U vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: 40 | struct B1 (virtual base) (empty) -// CHECK-X64: | [sizeof=64, align=32 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct U +// CHECK-X64-NEXT: 0 | (U vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: 40 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=64, align=32 +// CHECK-X64-NEXT: | nvsize=16, nvalign=32] struct __declspec(align(32)) V : virtual D1 { int a; @@ -665,19 +687,82 @@ struct __declspec(align(32)) V : virtual D1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct V -// CHECK: 0 | (V vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct D1 (virtual base) (empty) -// CHECK: | [sizeof=32, align=32 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct V +// CHECK-NEXT: 0 | (V vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct D1 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=32, align=32 +// CHECK-NEXT: | nvsize=8, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct V +// CHECK-X64-NEXT: 0 | (V vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct D1 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=32, align=32 +// CHECK-X64-NEXT: | nvsize=16, nvalign=32] + +struct T0 {}; +struct T1 : T0 { char a; }; +struct T3 : virtual T1, virtual T0 { long long a; }; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct T3 +// CHECK-NEXT: 0 | (T3 vbtable pointer) +// CHECK-NEXT: 8 | long long a +// CHECK-NEXT: 16 | struct T1 (virtual base) +// CHECK-NEXT: 16 | struct T0 (base) (empty) +// CHECK-NEXT: 16 | char a +// CHECK-NEXT: 24 | struct T0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=16, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct T3 +// CHECK-X64-NEXT: 0 | (T3 vbtable pointer) +// CHECK-X64-NEXT: 8 | long long a +// CHECK-X64-NEXT: 16 | struct T1 (virtual base) +// CHECK-X64-NEXT: 16 | struct T0 (base) (empty) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 24 | struct T0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] + +struct Q0A {}; +struct Q0B { char Q0BField; }; +struct Q0C : virtual Q0A, virtual Q0B { char Q0CField; }; +struct Q0D : Q0C, Q0A {}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct Q0D +// CHECK-NEXT: 0 | struct Q0C (base) +// CHECK-NEXT: 0 | (Q0C vbtable pointer) +// CHECK-NEXT: 4 | char Q0CField +// CHECK-NEXT: 8 | struct Q0A (base) (empty) +// CHECK-NEXT: 8 | struct Q0A (virtual base) (empty) +// CHECK-NEXT: 8 | struct Q0B (virtual base) +// CHECK-NEXT: 8 | char Q0BField +// CHECK-NEXT: | [sizeof=9, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct V -// CHECK-X64: 0 | (V vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct D1 (virtual base) (empty) -// CHECK-X64: | [sizeof=32, align=32 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct Q0D +// CHECK-X64-NEXT: 0 | struct Q0C (base) +// CHECK-X64-NEXT: 0 | (Q0C vbtable pointer) +// CHECK-X64-NEXT: 8 | char Q0CField +// CHECK-X64-NEXT: 16 | struct Q0A (base) (empty) +// CHECK-X64-NEXT: 16 | struct Q0A (virtual base) (empty) +// CHECK-X64-NEXT: 16 | struct Q0B (virtual base) +// CHECK-X64-NEXT: 16 | char Q0BField +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] int a[ sizeof(A)+ @@ -701,4 +786,6 @@ sizeof(R)+ sizeof(S)+ sizeof(T)+ sizeof(U)+ -sizeof(V)]; \ No newline at end of file +sizeof(V)+ +sizeof(T3)+ +sizeof(Q0D)]; diff --git a/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp b/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp index 7dd3fad5bf45..34ae0cf9dde8 100644 --- a/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp +++ b/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -24,687 +24,786 @@ struct __declspec(align(2)) B3X { B3X() { printf("B3 = %p\n", this); } }; struct B4X { B4X() { printf("B4 = %p\n", this); } }; struct B5X { B5X() { printf("B5 = %p\n", this); } }; struct B6X { B6X() { printf("B6 = %p\n", this); } }; -struct B8X { short a; B8X() : a(0xf00000B8) { printf("B8 = %p\n", this); } }; +struct B8X { short a; B8X() : a(0x000000B8) { printf("B8 = %p\n", this); } }; struct AA : B8, B1, virtual B0 { int a; - AA() : a(0xf00000AA) { printf("AA = %p\n", this); } + AA() : a(0x000000AA) { printf("AA = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AA -// CHECK: 0 | struct B8 (base) -// CHECK: 0 | char [5] c -// CHECK: 13 | struct B1 (base) (empty) -// CHECK: 8 | (AA vbtable pointer) -// CHECK: 16 | int a -// CHECK: 20 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=20, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AA -// CHECK-X64: 0 | struct B8 (base) -// CHECK-X64: 0 | char [5] c -// CHECK-X64: 17 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AA vbtable pointer) -// CHECK-X64: 20 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct AA +// CHECK-NEXT: 0 | struct B8 (base) +// CHECK-NEXT: 0 | char [5] c +// CHECK-NEXT: 13 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AA vbtable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=20, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AA +// CHECK-X64-NEXT: 0 | struct B8 (base) +// CHECK-X64-NEXT: 0 | char [5] c +// CHECK-X64-NEXT: 17 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AA vbtable pointer) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AB : B8, B1, virtual B0 { short a; - AB() : a(0xf00000AB) { printf("AB = %p\n", this); } + AB() : a(0x000000AB) { printf("AB = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AB -// CHECK: 0 | struct B8 (base) -// CHECK: 0 | char [5] c -// CHECK: 13 | struct B1 (base) (empty) -// CHECK: 8 | (AB vbtable pointer) -// CHECK: 14 | short a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AB -// CHECK-X64: 0 | struct B8 (base) -// CHECK-X64: 0 | char [5] c -// CHECK-X64: 17 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AB vbtable pointer) -// CHECK-X64: 18 | short a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AB +// CHECK-NEXT: 0 | struct B8 (base) +// CHECK-NEXT: 0 | char [5] c +// CHECK-NEXT: 13 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AB vbtable pointer) +// CHECK-NEXT: 14 | short a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AB +// CHECK-X64-NEXT: 0 | struct B8 (base) +// CHECK-X64-NEXT: 0 | char [5] c +// CHECK-X64-NEXT: 17 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AB vbtable pointer) +// CHECK-X64-NEXT: 18 | short a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AC : B8, B1, virtual B0 { char a; - AC() : a(0xf00000AC) { printf("AC = %p\n", this); } + AC() : a(0x000000AC) { printf("AC = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AC -// CHECK: 0 | struct B8 (base) -// CHECK: 0 | char [5] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AC vbtable pointer) -// CHECK: 12 | char a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AC -// CHECK-X64: 0 | struct B8 (base) -// CHECK-X64: 0 | char [5] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AC vbtable pointer) -// CHECK-X64: 16 | char a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AC +// CHECK-NEXT: 0 | struct B8 (base) +// CHECK-NEXT: 0 | char [5] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AC vbtable pointer) +// CHECK-NEXT: 12 | char a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AC +// CHECK-X64-NEXT: 0 | struct B8 (base) +// CHECK-X64-NEXT: 0 | char [5] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AC vbtable pointer) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AD : B8, B1, virtual B0 { AD() { printf("AD = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AD -// CHECK: 0 | struct B8 (base) -// CHECK: 0 | char [5] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AD vbtable pointer) -// CHECK: 12 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AD -// CHECK-X64: 0 | struct B8 (base) -// CHECK-X64: 0 | char [5] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AD vbtable pointer) -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct AD +// CHECK-NEXT: 0 | struct B8 (base) +// CHECK-NEXT: 0 | char [5] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AD vbtable pointer) +// CHECK-NEXT: 12 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AD +// CHECK-X64-NEXT: 0 | struct B8 (base) +// CHECK-X64-NEXT: 0 | char [5] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AD vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct AA1 : B9, B1, virtual B0 { int a; - AA1() : a(0xf0000AA1) { printf("AA1 = %p\n", this); } + AA1() : a(0x00000AA1) { printf("AA1 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AA1 -// CHECK: 0 | struct B9 (base) -// CHECK: 0 | char [6] c -// CHECK: 14 | struct B1 (base) (empty) -// CHECK: 8 | (AA1 vbtable pointer) -// CHECK: 16 | int a -// CHECK: 20 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=20, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AA1 -// CHECK-X64: 0 | struct B9 (base) -// CHECK-X64: 0 | char [6] c -// CHECK-X64: 18 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AA1 vbtable pointer) -// CHECK-X64: 20 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct AA1 +// CHECK-NEXT: 0 | struct B9 (base) +// CHECK-NEXT: 0 | char [6] c +// CHECK-NEXT: 14 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AA1 vbtable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=20, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AA1 +// CHECK-X64-NEXT: 0 | struct B9 (base) +// CHECK-X64-NEXT: 0 | char [6] c +// CHECK-X64-NEXT: 18 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AA1 vbtable pointer) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AB1 : B9, B1, virtual B0 { short a; - AB1() : a(0xf0000AB1) { printf("AB1 = %p\n", this); } + AB1() : a(0x00000AB1) { printf("AB1 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AB1 -// CHECK: 0 | struct B9 (base) -// CHECK: 0 | char [6] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AB1 vbtable pointer) -// CHECK: 12 | short a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AB1 -// CHECK-X64: 0 | struct B9 (base) -// CHECK-X64: 0 | char [6] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AB1 vbtable pointer) -// CHECK-X64: 16 | short a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AB1 +// CHECK-NEXT: 0 | struct B9 (base) +// CHECK-NEXT: 0 | char [6] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AB1 vbtable pointer) +// CHECK-NEXT: 12 | short a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AB1 +// CHECK-X64-NEXT: 0 | struct B9 (base) +// CHECK-X64-NEXT: 0 | char [6] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AB1 vbtable pointer) +// CHECK-X64-NEXT: 16 | short a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AC1 : B9, B1, virtual B0 { char a; - AC1() : a(0xf0000AC1) { printf("AC1 = %p\n", this); } + AC1() : a(0x000000C1) { printf("AC1 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AC1 -// CHECK: 0 | struct B9 (base) -// CHECK: 0 | char [6] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AC1 vbtable pointer) -// CHECK: 12 | char a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AC1 -// CHECK-X64: 0 | struct B9 (base) -// CHECK-X64: 0 | char [6] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AC1 vbtable pointer) -// CHECK-X64: 16 | char a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AC1 +// CHECK-NEXT: 0 | struct B9 (base) +// CHECK-NEXT: 0 | char [6] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AC1 vbtable pointer) +// CHECK-NEXT: 12 | char a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AC1 +// CHECK-X64-NEXT: 0 | struct B9 (base) +// CHECK-X64-NEXT: 0 | char [6] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AC1 vbtable pointer) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AD1 : B9, B1, virtual B0 { AD1() { printf("AD1 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AD1 -// CHECK: 0 | struct B9 (base) -// CHECK: 0 | char [6] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AD1 vbtable pointer) -// CHECK: 12 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AD1 -// CHECK-X64: 0 | struct B9 (base) -// CHECK-X64: 0 | char [6] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AD1 vbtable pointer) -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct AD1 +// CHECK-NEXT: 0 | struct B9 (base) +// CHECK-NEXT: 0 | char [6] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AD1 vbtable pointer) +// CHECK-NEXT: 12 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AD1 +// CHECK-X64-NEXT: 0 | struct B9 (base) +// CHECK-X64-NEXT: 0 | char [6] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AD1 vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct AA2 : B10, B1, virtual B0 { int a; - AA2() : a(0xf0000AA2) { printf("AA2 = %p\n", this); } + AA2() : a(0x00000AA2) { printf("AA2 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AA2 -// CHECK: 0 | struct B10 (base) -// CHECK: 0 | char [7] c -// CHECK: 15 | struct B1 (base) (empty) -// CHECK: 8 | (AA2 vbtable pointer) -// CHECK: 16 | int a -// CHECK: 20 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=20, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AA2 -// CHECK-X64: 0 | struct B10 (base) -// CHECK-X64: 0 | char [7] c -// CHECK-X64: 19 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AA2 vbtable pointer) -// CHECK-X64: 20 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct AA2 +// CHECK-NEXT: 0 | struct B10 (base) +// CHECK-NEXT: 0 | char [7] c +// CHECK-NEXT: 15 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AA2 vbtable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=20, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AA2 +// CHECK-X64-NEXT: 0 | struct B10 (base) +// CHECK-X64-NEXT: 0 | char [7] c +// CHECK-X64-NEXT: 19 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AA2 vbtable pointer) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AB2 : B10, B1, virtual B0 { short a; - AB2() : a(0xf0000AB2) { printf("AB2 = %p\n", this); } + AB2() : a(0x00000AB2) { printf("AB2 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AB2 -// CHECK: 0 | struct B10 (base) -// CHECK: 0 | char [7] c -// CHECK: 13 | struct B1 (base) (empty) -// CHECK: 8 | (AB2 vbtable pointer) -// CHECK: 14 | short a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AB2 -// CHECK-X64: 0 | struct B10 (base) -// CHECK-X64: 0 | char [7] c -// CHECK-X64: 17 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AB2 vbtable pointer) -// CHECK-X64: 18 | short a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AB2 +// CHECK-NEXT: 0 | struct B10 (base) +// CHECK-NEXT: 0 | char [7] c +// CHECK-NEXT: 13 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AB2 vbtable pointer) +// CHECK-NEXT: 14 | short a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AB2 +// CHECK-X64-NEXT: 0 | struct B10 (base) +// CHECK-X64-NEXT: 0 | char [7] c +// CHECK-X64-NEXT: 17 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AB2 vbtable pointer) +// CHECK-X64-NEXT: 18 | short a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AC2 : B10, B1, virtual B0 { char a; - AC2() : a(0xf0000AC2) { printf("AC2 = %p\n", this); } + AC2() : a(0x000000C2) { printf("AC2 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AC2 -// CHECK: 0 | struct B10 (base) -// CHECK: 0 | char [7] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AC2 vbtable pointer) -// CHECK: 12 | char a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AC2 -// CHECK-X64: 0 | struct B10 (base) -// CHECK-X64: 0 | char [7] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AC2 vbtable pointer) -// CHECK-X64: 16 | char a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AC2 +// CHECK-NEXT: 0 | struct B10 (base) +// CHECK-NEXT: 0 | char [7] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AC2 vbtable pointer) +// CHECK-NEXT: 12 | char a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AC2 +// CHECK-X64-NEXT: 0 | struct B10 (base) +// CHECK-X64-NEXT: 0 | char [7] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AC2 vbtable pointer) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AD2 : B10, B1, virtual B0 { AD2() { printf("AD2 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AD2 -// CHECK: 0 | struct B10 (base) -// CHECK: 0 | char [7] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AD2 vbtable pointer) -// CHECK: 12 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AD2 -// CHECK-X64: 0 | struct B10 (base) -// CHECK-X64: 0 | char [7] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AD2 vbtable pointer) -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct AD2 +// CHECK-NEXT: 0 | struct B10 (base) +// CHECK-NEXT: 0 | char [7] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AD2 vbtable pointer) +// CHECK-NEXT: 12 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AD2 +// CHECK-X64-NEXT: 0 | struct B10 (base) +// CHECK-X64-NEXT: 0 | char [7] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AD2 vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct AA3 : B11, B1, virtual B0 { int a; - AA3() : a(0xf0000AA3) { printf("AA3 = %p\n", this); } + AA3() : a(0x00000AA3) { printf("AA3 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AA3 -// CHECK: 0 | struct B11 (base) -// CHECK: 0 | char [8] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AA3 vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AA3 -// CHECK-X64: 0 | struct B11 (base) -// CHECK-X64: 0 | char [8] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AA3 vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct AA3 +// CHECK-NEXT: 0 | struct B11 (base) +// CHECK-NEXT: 0 | char [8] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AA3 vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AA3 +// CHECK-X64-NEXT: 0 | struct B11 (base) +// CHECK-X64-NEXT: 0 | char [8] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AA3 vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AB3 : B11, B1, virtual B0 { short a; - AB3() : a(0xf0000AB3) { printf("AB3 = %p\n", this); } + AB3() : a(0x00000AB3) { printf("AB3 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AB3 -// CHECK: 0 | struct B11 (base) -// CHECK: 0 | char [8] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AB3 vbtable pointer) -// CHECK: 12 | short a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AB3 -// CHECK-X64: 0 | struct B11 (base) -// CHECK-X64: 0 | char [8] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AB3 vbtable pointer) -// CHECK-X64: 16 | short a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AB3 +// CHECK-NEXT: 0 | struct B11 (base) +// CHECK-NEXT: 0 | char [8] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AB3 vbtable pointer) +// CHECK-NEXT: 12 | short a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AB3 +// CHECK-X64-NEXT: 0 | struct B11 (base) +// CHECK-X64-NEXT: 0 | char [8] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AB3 vbtable pointer) +// CHECK-X64-NEXT: 16 | short a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AC3 : B11, B1, virtual B0 { char a; - AC3() : a(0xf0000AC3) { printf("AC3 = %p\n", this); } + AC3() : a(0x000000C3) { printf("AC3 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AC3 -// CHECK: 0 | struct B11 (base) -// CHECK: 0 | char [8] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AC3 vbtable pointer) -// CHECK: 12 | char a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AC3 -// CHECK-X64: 0 | struct B11 (base) -// CHECK-X64: 0 | char [8] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AC3 vbtable pointer) -// CHECK-X64: 16 | char a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct AC3 +// CHECK-NEXT: 0 | struct B11 (base) +// CHECK-NEXT: 0 | char [8] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AC3 vbtable pointer) +// CHECK-NEXT: 12 | char a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AC3 +// CHECK-X64-NEXT: 0 | struct B11 (base) +// CHECK-X64-NEXT: 0 | char [8] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AC3 vbtable pointer) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct AD3 : B11, B1, virtual B0 { AD3() { printf("AD3 = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AD3 -// CHECK: 0 | struct B11 (base) -// CHECK: 0 | char [8] c -// CHECK: 12 | struct B1 (base) (empty) -// CHECK: 8 | (AD3 vbtable pointer) -// CHECK: 12 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AD3 -// CHECK-X64: 0 | struct B11 (base) -// CHECK-X64: 0 | char [8] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (AD3 vbtable pointer) -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-NEXT: 0 | struct AD3 +// CHECK-NEXT: 0 | struct B11 (base) +// CHECK-NEXT: 0 | char [8] c +// CHECK-NEXT: 12 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (AD3 vbtable pointer) +// CHECK-NEXT: 12 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AD3 +// CHECK-X64-NEXT: 0 | struct B11 (base) +// CHECK-X64-NEXT: 0 | char [8] c +// CHECK-X64-NEXT: 16 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (AD3 vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct B : B1, B2, virtual B0 { B() { printf("B = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | struct B1 (base) (empty) -// CHECK: 8 | struct B2 (base) (empty) -// CHECK: 4 | (B vbtable pointer) -// CHECK: 8 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | struct B2 (base) (empty) +// CHECK-NEXT: 4 | (B vbtable pointer) +// CHECK-NEXT: 8 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | struct B1 (base) (empty) -// CHECK-X64: 16 | struct B2 (base) (empty) -// CHECK-X64: 8 | (B vbtable pointer) -// CHECK-X64: 16 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 16 | struct B2 (base) (empty) +// CHECK-X64-NEXT: 8 | (B vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct C : B1, B2, B3, virtual B0 { char a; - C() : a(0xf000000C) { printf("C = %p\n", this); } + C() : a(0x0000000C) { printf("C = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | struct B1 (base) (empty) -// CHECK: 1 | struct B2 (base) (empty) -// CHECK: 8 | struct B3 (base) (empty) -// CHECK: 4 | (C vbtable pointer) -// CHECK: 8 | char a -// CHECK: 12 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | struct B1 (base) (empty) -// CHECK-X64: 1 | struct B2 (base) (empty) -// CHECK-X64: 16 | struct B3 (base) (empty) -// CHECK-X64: 8 | (C vbtable pointer) -// CHECK-X64: 16 | char a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | struct B1 (base) (empty) +// CHECK-NEXT: 1 | struct B2 (base) (empty) +// CHECK-NEXT: 8 | struct B3 (base) (empty) +// CHECK-NEXT: 4 | (C vbtable pointer) +// CHECK-NEXT: 8 | char a +// CHECK-NEXT: 12 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 1 | struct B2 (base) (empty) +// CHECK-X64-NEXT: 16 | struct B3 (base) (empty) +// CHECK-X64-NEXT: 8 | (C vbtable pointer) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct D : B1, B2, B3, B4, B5, virtual B0 { int a; - D() : a(0xf000000D) { printf("D = %p\n", this); } + D() : a(0x0000000D) { printf("D = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | struct B1 (base) (empty) -// CHECK: 1 | struct B2 (base) (empty) -// CHECK: 2 | struct B3 (base) (empty) -// CHECK: 3 | struct B4 (base) (empty) -// CHECK: 8 | struct B5 (base) (empty) -// CHECK: 4 | (D vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | struct B1 (base) (empty) -// CHECK-X64: 1 | struct B2 (base) (empty) -// CHECK-X64: 2 | struct B3 (base) (empty) -// CHECK-X64: 3 | struct B4 (base) (empty) -// CHECK-X64: 16 | struct B5 (base) (empty) -// CHECK-X64: 8 | (D vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | struct B1 (base) (empty) +// CHECK-NEXT: 1 | struct B2 (base) (empty) +// CHECK-NEXT: 2 | struct B3 (base) (empty) +// CHECK-NEXT: 3 | struct B4 (base) (empty) +// CHECK-NEXT: 8 | struct B5 (base) (empty) +// CHECK-NEXT: 4 | (D vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=12, 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 D +// CHECK-X64-NEXT: 0 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 1 | struct B2 (base) (empty) +// CHECK-X64-NEXT: 2 | struct B3 (base) (empty) +// CHECK-X64-NEXT: 3 | struct B4 (base) (empty) +// CHECK-X64-NEXT: 16 | struct B5 (base) (empty) +// CHECK-X64-NEXT: 8 | (D vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct E : B1, B6, B3, B4, B5, virtual B0 { int a; - E() : a(0xf000000E) { printf("E = %p\n", this); } + E() : a(0x0000000E) { printf("E = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | struct B1 (base) (empty) -// CHECK: 2 | struct B6 (base) (empty) -// CHECK: 3 | struct B3 (base) (empty) -// CHECK: 4 | struct B4 (base) (empty) -// CHECK: 13 | struct B5 (base) (empty) -// CHECK: 8 | (E vbtable pointer) -// CHECK: 16 | int a -// CHECK: 20 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=20, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct E -// CHECK-X64: 0 | struct B1 (base) (empty) -// CHECK-X64: 2 | struct B6 (base) (empty) -// CHECK-X64: 3 | struct B3 (base) (empty) -// CHECK-X64: 4 | struct B4 (base) (empty) -// CHECK-X64: 17 | struct B5 (base) (empty) -// CHECK-X64: 8 | (E vbtable pointer) -// CHECK-X64: 20 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | struct B1 (base) (empty) +// CHECK-NEXT: 2 | struct B6 (base) (empty) +// CHECK-NEXT: 3 | struct B3 (base) (empty) +// CHECK-NEXT: 4 | struct B4 (base) (empty) +// CHECK-NEXT: 13 | struct B5 (base) (empty) +// CHECK-NEXT: 8 | (E vbtable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=20, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 2 | struct B6 (base) (empty) +// CHECK-X64-NEXT: 3 | struct B3 (base) (empty) +// CHECK-X64-NEXT: 4 | struct B4 (base) (empty) +// CHECK-X64-NEXT: 17 | struct B5 (base) (empty) +// CHECK-X64-NEXT: 8 | (E vbtable pointer) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct F : B1, B6, B4, B8, B5, virtual B0 { int a; - F() : a(0xf000000F) { printf("&a = %p\n", &a); printf("F = %p\n", this); } + F() : a(0x0000000F) { printf("&a = %p\n", &a); printf("F = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | struct B1 (base) (empty) -// CHECK: 2 | struct B6 (base) (empty) -// CHECK: 3 | struct B4 (base) (empty) -// CHECK: 3 | struct B8 (base) -// CHECK: 3 | char [5] c -// CHECK: 12 | struct B5 (base) (empty) -// CHECK: 8 | (F vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F -// CHECK-X64: 0 | struct B1 (base) (empty) -// CHECK-X64: 2 | struct B6 (base) (empty) -// CHECK-X64: 3 | struct B4 (base) (empty) -// CHECK-X64: 3 | struct B8 (base) -// CHECK-X64: 3 | char [5] c -// CHECK-X64: 16 | struct B5 (base) (empty) -// CHECK-X64: 8 | (F vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | struct B1 (base) (empty) +// CHECK-NEXT: 2 | struct B6 (base) (empty) +// CHECK-NEXT: 3 | struct B4 (base) (empty) +// CHECK-NEXT: 3 | struct B8 (base) +// CHECK-NEXT: 3 | char [5] c +// CHECK-NEXT: 12 | struct B5 (base) (empty) +// CHECK-NEXT: 8 | (F vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct F +// CHECK-X64-NEXT: 0 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 2 | struct B6 (base) (empty) +// CHECK-X64-NEXT: 3 | struct B4 (base) (empty) +// CHECK-X64-NEXT: 3 | struct B8 (base) +// CHECK-X64-NEXT: 3 | char [5] c +// CHECK-X64-NEXT: 16 | struct B5 (base) (empty) +// CHECK-X64-NEXT: 8 | (F vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct G : B8, B1, virtual B0 { int a; __declspec(align(16)) int a1; - G() : a(0xf0000010), a1(0xf0000010) { printf("G = %p\n", this); } + G() : a(0x00000010), a1(0xf0000010) { printf("G = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct G -// CHECK: 0 | struct B8 (base) -// CHECK: 0 | char [5] c -// CHECK: 21 | struct B1 (base) (empty) -// CHECK: 8 | (G vbtable pointer) -// CHECK: 24 | int a -// CHECK: 32 | int a1 -// CHECK: 48 | struct B0 (virtual base) (empty) -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=48, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct G -// CHECK-X64: 0 | struct B8 (base) -// CHECK-X64: 0 | char [5] c -// CHECK-X64: 16 | struct B1 (base) (empty) -// CHECK-X64: 8 | (G vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | int a1 -// CHECK-X64: 48 | struct B0 (virtual base) (empty) -// CHECK-X64: | [sizeof=48, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct G +// CHECK-NEXT: 0 | struct B8 (base) +// CHECK-NEXT: 0 | char [5] c +// CHECK-NEXT: 21 | struct B1 (base) (empty) +// CHECK-NEXT: 8 | (G vbtable pointer) +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: 32 | int a1 +// CHECK-NEXT: 48 | struct B0 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct G +// CHECK-X64-NEXT: 0 | struct B8 (base) +// CHECK-X64-NEXT: 0 | char [5] c +// CHECK-X64-NEXT: 21 | struct B1 (base) (empty) +// CHECK-X64-NEXT: 8 | (G vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | int a1 +// CHECK-X64-NEXT: 48 | struct B0 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=48, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct AX : B1X, B2X, B3X, B4X, virtual B0X { int a; - AX() : a(0xf000000A) { printf(" A = %p\n", this); } + AX() : a(0x0000000A) { printf(" A = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AX -// CHECK: 0 | struct B1X (base) (empty) -// CHECK: 16 | struct B2X (base) (empty) -// CHECK: 18 | struct B3X (base) (empty) -// CHECK: 35 | struct B4X (base) (empty) -// CHECK: 20 | (AX vbtable pointer) -// CHECK: 36 | int a -// CHECK: 48 | struct B0X (virtual base) (empty) -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=48, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AX -// CHECK-X64: 0 | struct B1X (base) (empty) -// CHECK-X64: 16 | struct B2X (base) (empty) -// CHECK-X64: 18 | struct B3X (base) (empty) -// CHECK-X64: 33 | struct B4X (base) (empty) -// CHECK-X64: 24 | (AX vbtable pointer) -// CHECK-X64: 36 | int a -// CHECK-X64: 48 | struct B0X (virtual base) (empty) -// CHECK-X64: | [sizeof=48, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// 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 | struct B1X (base) (empty) +// CHECK-NEXT: 16 | struct B2X (base) (empty) +// CHECK-NEXT: 18 | struct B3X (base) (empty) +// CHECK-NEXT: 35 | struct B4X (base) (empty) +// CHECK-NEXT: 20 | (AX vbtable pointer) +// CHECK-NEXT: 36 | int a +// CHECK-NEXT: 48 | struct B0X (virtual base) (empty) +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=48, 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 +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct AX +// CHECK-X64-NEXT: 0 | struct B1X (base) (empty) +// CHECK-X64-NEXT: 16 | struct B2X (base) (empty) +// CHECK-X64-NEXT: 18 | struct B3X (base) (empty) +// CHECK-X64-NEXT: 35 | struct B4X (base) (empty) +// CHECK-X64-NEXT: 24 | (AX vbtable pointer) +// CHECK-X64-NEXT: 36 | int a +// CHECK-X64-NEXT: 48 | struct B0X (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=48, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct BX : B2X, B1X, B3X, B4X, virtual B0X { int a; - BX() : a(0xf000000B) { printf(" B = %p\n", this); } + BX() : a(0x0000000B) { printf(" B = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct BX -// CHECK: 0 | struct B2X (base) (empty) -// CHECK: 1 | struct B1X (base) (empty) -// CHECK: 2 | struct B3X (base) (empty) -// CHECK: 19 | struct B4X (base) (empty) -// CHECK: 4 | (BX vbtable pointer) -// CHECK: 20 | int a -// CHECK: 32 | struct B0X (virtual base) (empty) -// CHECK: | [sizeof=32, align=16 -// CHECK: | nvsize=32, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct BX -// CHECK-X64: 0 | struct B2X (base) (empty) -// CHECK-X64: 1 | struct B1X (base) (empty) -// CHECK-X64: 2 | struct B3X (base) (empty) -// CHECK-X64: 17 | struct B4X (base) (empty) -// CHECK-X64: 8 | (BX vbtable pointer) -// CHECK-X64: 20 | int a -// CHECK-X64: 32 | struct B0X (virtual base) (empty) -// CHECK-X64: | [sizeof=32, align=16 -// CHECK-X64: | nvsize=32, nvalign=16] +// CHECK-NEXT: 0 | struct BX +// CHECK-NEXT: 0 | struct B2X (base) (empty) +// CHECK-NEXT: 1 | struct B1X (base) (empty) +// CHECK-NEXT: 2 | struct B3X (base) (empty) +// CHECK-NEXT: 19 | struct B4X (base) (empty) +// CHECK-NEXT: 4 | (BX vbtable pointer) +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: 32 | struct B0X (virtual base) (empty) +// CHECK-NEXT: | [sizeof=32, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct BX +// CHECK-X64-NEXT: 0 | struct B2X (base) (empty) +// CHECK-X64-NEXT: 1 | struct B1X (base) (empty) +// CHECK-X64-NEXT: 2 | struct B3X (base) (empty) +// CHECK-X64-NEXT: 19 | struct B4X (base) (empty) +// CHECK-X64-NEXT: 8 | (BX vbtable pointer) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 32 | struct B0X (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=32, align=16 +// CHECK-X64-NEXT: | nvsize=32, nvalign=16] struct CX : B1X, B3X, B2X, virtual B0X { int a; - CX() : a(0xf000000C) { printf(" C = %p\n", this); } + CX() : a(0x0000000C) { printf(" C = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct CX -// CHECK: 0 | struct B1X (base) (empty) -// CHECK: 2 | struct B3X (base) (empty) -// CHECK: 32 | struct B2X (base) (empty) -// CHECK: 4 | (CX vbtable pointer) -// CHECK: 32 | int a -// CHECK: 48 | struct B0X (virtual base) (empty) -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=48, nvalign=16] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct CX -// CHECK-X64: 0 | struct B1X (base) (empty) -// CHECK-X64: 2 | struct B3X (base) (empty) -// CHECK-X64: 32 | struct B2X (base) (empty) -// CHECK-X64: 8 | (CX vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B0X (virtual base) (empty) -// CHECK-X64: | [sizeof=48, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct CX +// CHECK-NEXT: 0 | struct B1X (base) (empty) +// CHECK-NEXT: 2 | struct B3X (base) (empty) +// CHECK-NEXT: 32 | struct B2X (base) (empty) +// CHECK-NEXT: 16 | (CX vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 48 | struct B0X (virtual base) (empty) +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct CX +// CHECK-X64-NEXT: 0 | struct B1X (base) (empty) +// CHECK-X64-NEXT: 2 | struct B3X (base) (empty) +// CHECK-X64-NEXT: 32 | struct B2X (base) (empty) +// CHECK-X64-NEXT: 16 | (CX vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 48 | struct B0X (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=48, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct DX : B8X, B1X, virtual B0X { int a; - DX() : a(0xf000000D) { printf(" D = %p\n", this); } + DX() : a(0x0000000D) { printf(" D = %p\n", this); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct DX -// CHECK: 0 | struct B8X (base) -// CHECK: 0 | short a -// CHECK: 10 | struct B1X (base) (empty) -// CHECK: 4 | (DX vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | struct B0X (virtual base) (empty) -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct DX -// CHECK-X64: 0 | struct B8X (base) -// CHECK-X64: 0 | short a -// CHECK-X64: 18 | struct B1X (base) (empty) -// CHECK-X64: 8 | (DX vbtable pointer) -// CHECK-X64: 20 | int a -// CHECK-X64: 24 | struct B0X (virtual base) (empty) -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct DX +// CHECK-NEXT: 0 | struct B8X (base) +// CHECK-NEXT: 0 | short a +// CHECK-NEXT: 10 | struct B1X (base) (empty) +// CHECK-NEXT: 4 | (DX vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct B0X (virtual base) (empty) +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct DX +// CHECK-X64-NEXT: 0 | struct B8X (base) +// CHECK-X64-NEXT: 0 | short a +// CHECK-X64-NEXT: 18 | struct B1X (base) (empty) +// CHECK-X64-NEXT: 8 | (DX vbtable pointer) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 24 | struct B0X (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] + + +struct C0 {}; +struct C1 : public C0 { int C1F0; }; +struct C2 : public C1, public C0 {}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct C2 +// CHECK-NEXT: 0 | struct C1 (base) +// CHECK-NEXT: 0 | struct C0 (base) (empty) +// CHECK-NEXT: 0 | int C1F0 +// CHECK-NEXT: 5 | struct C0 (base) (empty) +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, 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 C2 +// CHECK-X64-NEXT: 0 | struct C1 (base) +// CHECK-X64-NEXT: 0 | struct C0 (base) (empty) +// CHECK-X64-NEXT: 0 | int C1F0 +// CHECK-X64-NEXT: 5 | struct C0 (base) (empty) +// CHECK-X64-NEXT: | [sizeof=8, align=4 +// CHECK-X64-NEXT: | nvsize=8, nvalign=4] + +struct JA { char a; }; +struct JB { + char a; + virtual void f() {} +}; +struct JC { char a; }; +struct JD : JA, JB, virtual JC {}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct JD +// CHECK-NEXT: 0 | struct JB (primary base) +// CHECK-NEXT: 0 | (JB vftable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 12 | struct JA (base) +// CHECK-NEXT: 12 | char a +// CHECK-NEXT: 8 | (JD vbtable pointer) +// CHECK-NEXT: 16 | struct JC (virtual base) +// CHECK-NEXT: 16 | char a +// CHECK-NEXT: | [sizeof=17, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct JD +// CHECK-X64-NEXT: 0 | struct JB (primary base) +// CHECK-X64-NEXT: 0 | (JB vftable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 24 | struct JA (base) +// CHECK-X64-NEXT: 24 | char a +// CHECK-X64-NEXT: 16 | (JD vbtable pointer) +// CHECK-X64-NEXT: 32 | struct JC (virtual base) +// CHECK-X64-NEXT: 32 | char a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=32, nvalign=8] int a[ sizeof(AA)+ @@ -732,4 +831,7 @@ sizeof(G)+ sizeof(AX)+ sizeof(BX)+ sizeof(CX)+ -sizeof(DX)]; +sizeof(DX)+ +sizeof(C2)+ +sizeof(JD)+ +0]; diff --git a/test/Layout/ms-x86-member-pointers.cpp b/test/Layout/ms-x86-member-pointers.cpp new file mode 100644 index 000000000000..89dd211a3515 --- /dev/null +++ b/test/Layout/ms-x86-member-pointers.cpp @@ -0,0 +1,80 @@ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fms-extensions -fsyntax-only %s 2>&1 | FileCheck %s + +struct __single_inheritance S; +struct __multiple_inheritance M; +struct __virtual_inheritance V; +struct U; + +struct SD { char a; int S::*mp; }; +struct MD { char a; int M::*mp; }; +struct VD { char a; int V::*mp; }; +struct UD { char a; int U::*mp; }; +struct SF { char a; int (S::*mp)(); }; +struct MF { char a; int (M::*mp)(); }; +struct VF { char a; int (V::*mp)(); }; +struct UF { char a; int (U::*mp)(); }; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct SD +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 4 | int struct S::* mp +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct MD +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 4 | int struct M::* mp +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct VD +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 8 | int struct V::* mp +// CHECK-NEXT: | [sizeof=16, align=8 +// CHECK-NEXT: | nvsize=16, nvalign=8] + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct UD +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 8 | int struct U::* mp +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=24, nvalign=8] + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct SF +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 4 | int (struct S::*)(void) __attribute__((thiscall)) mp +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct MF +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 8 | int (struct M::*)(void) __attribute__((thiscall)) mp +// CHECK-NEXT: | [sizeof=16, align=8 +// CHECK-NEXT: | nvsize=16, nvalign=8] + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct VF +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 8 | int (struct V::*)(void) __attribute__((thiscall)) mp +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=24, nvalign=8] + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct UF +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 8 | int (struct U::*)(void) __attribute__((thiscall)) mp +// CHECK-NEXT: | [sizeof=24, align=8 +// CHECK-NEXT: | nvsize=24, nvalign=8] + +char a[sizeof(SD) + + sizeof(MD) + + sizeof(VD) + + sizeof(UD) + + sizeof(SF) + + sizeof(MF) + + sizeof(VF) + + sizeof(UF)]; diff --git a/test/Layout/ms-x86-misalignedarray.cpp b/test/Layout/ms-x86-misalignedarray.cpp index f6887daf15b6..de5bcc7c35c2 100644 --- a/test/Layout/ms-x86-misalignedarray.cpp +++ b/test/Layout/ms-x86-misalignedarray.cpp @@ -1,23 +1,27 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 -struct T0 { char c; }; -struct T2 : virtual T0 { }; -struct T3 { T2 a[1]; char c; }; +struct T0 { char c; }; +struct T2 : virtual T0 { }; +struct T3 { T2 a[1]; char c; }; -// CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct T3 -// CHECK: 0 | struct T2 [1] a -// CHECK: 5 | char c -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=8, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct T3 -// CHECK-X64: 0 | struct T2 [1] a -// CHECK-X64: 16 | char c -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct T3 +// CHECK-NEXT: 0 | struct T2 [1] a +// CHECK-NEXT: 5 | char c +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, 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 T3 +// CHECK-X64-NEXT: 0 | struct T2 [1] a +// CHECK-X64-NEXT: 16 | char c +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] int a[sizeof(T3)]; diff --git a/test/Layout/ms-x86-pack-and-align.cpp b/test/Layout/ms-x86-pack-and-align.cpp new file mode 100644 index 000000000000..5e1aae1ca757 --- /dev/null +++ b/test/Layout/ms-x86-pack-and-align.cpp @@ -0,0 +1,683 @@ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \ +// RUN: | FileCheck %s +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ +// 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 +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct X +// CHECK-NEXT: 0 | struct B a +// CHECK-NEXT: 0 | long long a +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=8, nvalign=8] +// CHECK-NEXT: 8 | char b +// CHECK-NEXT: 10 | int c +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=14, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct X +// CHECK-X64-NEXT: 0 | struct B a +// CHECK-X64-NEXT: 0 | long long a +// CHECK-X64-NEXT: | [sizeof=8, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 8 | char b +// CHECK-X64-NEXT: 10 | int c +// CHECK-X64-NEXT: | [sizeof=16, align=4 +// CHECK-X64-NEXT: | nvsize=14, nvalign=4] + +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 +// 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 +// CHECK-NEXT: | nvsize=18, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// 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 +// CHECK-X64-NEXT: | nvsize=18, nvalign=4] + +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 +// 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] +// CHECK-X64: *** Dumping AST Record Layout +// 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] + +#pragma pack(pop) + +struct A1 { long long a; }; +#pragma pack(push, 1) +struct B1 : virtual A1 { char a; }; +#pragma pack(pop) +struct C1 : B1 {}; + +// CHECK: *** Dumping AST Record Layout +// 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] +// CHECK-X64: *** Dumping AST Record Layout +// 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] + +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 +// 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] +// 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] + +#pragma pack(16) +struct YA { + __declspec(align(32)) char : 1; +}; +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct YA (empty) +// CHECK-NEXT: 0 | char +// CHECK-NEXT: | [sizeof=32, align=32 +// CHECK-NEXT: | nvsize=32, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct YA (empty) +// CHECK-X64-NEXT: 0 | char +// 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 +// CHECK-NEXT: 1 | struct YA b (empty) +// CHECK-NEXT: 1 | char +// CHECK-NEXT: | [sizeof=32, align=32 +// CHECK-NEXT: | nvsize=32, nvalign=32] +// CHECK-NEXT: | [sizeof=33, align=1 +// CHECK-NEXT: | nvsize=33, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct YB +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 1 | struct YA b (empty) +// CHECK-X64-NEXT: 1 | char +// CHECK-X64-NEXT: | [sizeof=32, align=32 +// CHECK-X64-NEXT: | nvsize=32, nvalign=32] +// CHECK-X64-NEXT: | [sizeof=33, align=1 +// CHECK-X64-NEXT: | nvsize=33, nvalign=1] + +#pragma pack(8) +struct YC { + __declspec(align(32)) char : 1; +}; +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct YC (empty) +// CHECK-NEXT: 0 | char +// CHECK-NEXT: | [sizeof=32, align=32 +// CHECK-NEXT: | nvsize=32, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct YC (empty) +// CHECK-X64-NEXT: 0 | char +// CHECK-X64-NEXT: | [sizeof=8, align=32 +// CHECK-X64-NEXT: | nvsize=8, nvalign=32] + +#pragma pack(1) +struct YD { + char a; + YC b; +}; +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct YD +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 1 | struct YC b (empty) +// CHECK-NEXT: 1 | char +// CHECK-NEXT: | [sizeof=32, align=32 +// CHECK-NEXT: | nvsize=32, nvalign=32] +// CHECK-NEXT: | [sizeof=33, align=1 +// CHECK-NEXT: | nvsize=33, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct YD +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 1 | struct YC b (empty) +// CHECK-X64-NEXT: 1 | char +// CHECK-X64-NEXT: | [sizeof=8, align=32 +// CHECK-X64-NEXT: | nvsize=8, nvalign=32] +// CHECK-X64-NEXT: | [sizeof=9, align=1 +// CHECK-X64-NEXT: | nvsize=9, nvalign=1] + +#pragma pack(4) +struct YE { + __declspec(align(32)) char : 1; +}; +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct YE (empty) +// CHECK-NEXT: 0 | char +// CHECK-NEXT: | [sizeof=4, align=32 +// CHECK-NEXT: | nvsize=4, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct YE (empty) +// CHECK-X64-NEXT: 0 | char +// CHECK-X64-NEXT: | [sizeof=4, align=32 +// CHECK-X64-NEXT: | nvsize=4, nvalign=32] + +#pragma pack(1) +struct YF { + char a; + YE b; +}; +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct YF +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 1 | struct YE b (empty) +// CHECK-NEXT: 1 | char +// CHECK-NEXT: | [sizeof=4, align=32 +// CHECK-NEXT: | nvsize=4, nvalign=32] +// CHECK-NEXT: | [sizeof=5, align=1 +// CHECK-NEXT: | nvsize=5, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct YF +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 1 | struct YE b (empty) +// CHECK-X64-NEXT: 1 | char +// CHECK-X64-NEXT: | [sizeof=4, align=32 +// CHECK-X64-NEXT: | nvsize=4, nvalign=32] +// CHECK-X64-NEXT: | [sizeof=5, align=1 +// CHECK-X64-NEXT: | nvsize=5, nvalign=1] + +#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] + +#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] + +#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] +// 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] + +#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] + +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 +// CHECK-NEXT: 0 | int b +// 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) +// CHECK-NEXT: 1024 | int b +// 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) +// CHECK-NEXT: 1024 | int b +// CHECK-NEXT: 1028 | struct RA (virtual base) (empty) +// 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) +// CHECK-NEXT: 2048 | int b +// CHECK-NEXT: 2052 | struct RA (virtual base) (empty) +// 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 _ +// CHECK-NEXT: 1024 | int c +// 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 _ +// CHECK-NEXT: 1025 | int c +// CHECK-NEXT: | [sizeof=1028, align=1024 +// CHECK-NEXT: | nvsize=1028, nvalign=1024] +// CHECK-NEXT: | [sizeof=1029, align=1 +// CHECK-NEXT: | nvsize=1029, nvalign=1] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct RB0 +// CHECK-X64-NEXT: 0 | int b +// 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) +// CHECK-X64-NEXT: 1024 | int b +// 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) +// CHECK-X64-NEXT: 1024 | int b +// CHECK-X64-NEXT: 1028 | struct RA (virtual base) (empty) +// 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) +// CHECK-X64-NEXT: 2048 | int b +// CHECK-X64-NEXT: 2052 | struct RA (virtual base) (empty) +// 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 _ +// CHECK-X64-NEXT: 1024 | int c +// 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 _ +// CHECK-X64-NEXT: 1025 | int c +// CHECK-X64-NEXT: | [sizeof=1028, align=1024 +// CHECK-X64-NEXT: | nvsize=1028, nvalign=1024] +// CHECK-X64-NEXT: | [sizeof=1029, align=1 +// CHECK-X64-NEXT: | nvsize=1029, nvalign=1] + +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] + +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] + + + +int a[ +sizeof(X)+ +sizeof(Y)+ +sizeof(Z)+ +sizeof(C1)+ +sizeof(CA2)+ +sizeof(YA)+ +sizeof(YB)+ +sizeof(YC)+ +sizeof(YD)+ +sizeof(YE)+ +sizeof(YF)+ +sizeof(YF)+ +sizeof(D2)+ +sizeof(JC)+ +sizeof(KB)+ +sizeof(L)+ +sizeof(MB)+ +sizeof(RB0)+ +sizeof(RB1)+ +sizeof(RB2)+ +sizeof(RB3)+ +sizeof(RC)+ +sizeof(RE)+ +sizeof(ND)+ +sizeof(OD)+ +0]; diff --git a/test/Layout/ms-x86-primary-bases.cpp b/test/Layout/ms-x86-primary-bases.cpp index bc9b801d99c8..b5bd041fa116 100644 --- a/test/Layout/ms-x86-primary-bases.cpp +++ b/test/Layout/ms-x86-primary-bases.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -16,65 +16,67 @@ struct A : virtual B0 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | (A vbtable pointer) -// CHECK: 4 | struct B0 (virtual base) -// CHECK: 4 | (B0 vftable pointer) -// CHECK: 8 | int a -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=4, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | (A vbtable pointer) +// CHECK-NEXT: 4 | struct B0 (virtual base) +// CHECK-NEXT: 4 | (B0 vftable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct A -// CHECK-X64: 0 | (A vbtable pointer) -// CHECK-X64: 8 | struct B0 (virtual base) -// CHECK-X64: 8 | (B0 vftable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 0 | struct A +// CHECK-X64-NEXT: 0 | (A vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B0 (virtual base) +// CHECK-X64-NEXT: 8 | (B0 vftable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] struct B : virtual B0 { virtual void f() { printf("B"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | (B vbtable pointer) -// CHECK: 4 | struct B0 (virtual base) -// CHECK: 4 | (B0 vftable pointer) -// CHECK: 8 | int a -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=4, nvalign=4] +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | (B vbtable pointer) +// CHECK-NEXT: 4 | struct B0 (virtual base) +// CHECK-NEXT: 4 | (B0 vftable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | (B vbtable pointer) -// CHECK-X64: 8 | struct B0 (virtual base) -// CHECK-X64: 8 | (B0 vftable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | (B vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B0 (virtual base) +// CHECK-X64-NEXT: 8 | (B0 vftable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] struct C : virtual B0 { virtual void g() { printf("A"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | (C vftable pointer) -// CHECK: 4 | (C vbtable pointer) -// CHECK: 8 | struct B0 (virtual base) -// CHECK: 8 | (B0 vftable pointer) -// CHECK: 12 | int a -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | (C vftable pointer) +// CHECK-NEXT: 4 | (C vbtable pointer) +// CHECK-NEXT: 8 | struct B0 (virtual base) +// CHECK-NEXT: 8 | (B0 vftable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | (C vftable pointer) -// CHECK-X64: 8 | (C vbtable pointer) -// CHECK-X64: 16 | struct B0 (virtual base) -// CHECK-X64: 16 | (B0 vftable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: | [sizeof=32, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | (C vftable pointer) +// CHECK-X64-NEXT: 8 | (C vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | (B0 vftable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: | [sizeof=32, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct D : virtual B2, virtual B0 { virtual void f() { printf("D"); } @@ -82,27 +84,29 @@ struct D : virtual B2, virtual B0 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | (D vftable pointer) -// CHECK: 4 | (D vbtable pointer) -// CHECK: 8 | struct B2 (virtual base) -// CHECK: 8 | int a -// CHECK: 12 | struct B0 (virtual base) -// CHECK: 12 | (B0 vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | (D vftable pointer) +// CHECK-NEXT: 4 | (D vbtable pointer) +// CHECK-NEXT: 8 | struct B2 (virtual base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct B0 (virtual base) +// CHECK-NEXT: 12 | (B0 vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | (D vftable pointer) -// CHECK-X64: 8 | (D vbtable pointer) -// CHECK-X64: 16 | struct B2 (virtual base) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B0 (virtual base) -// CHECK-X64: 24 | (B0 vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | (D vftable pointer) +// CHECK-X64-NEXT: 8 | (D vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B2 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B0 (virtual base) +// CHECK-X64-NEXT: 24 | (B0 vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct E : B0, virtual B1 { virtual void f() { printf("E"); } @@ -110,197 +114,205 @@ struct E : B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | struct B0 (primary base) -// CHECK: 0 | (B0 vftable pointer) -// CHECK: 4 | int a -// CHECK: 8 | (E vbtable pointer) -// CHECK: 12 | struct B1 (virtual base) -// CHECK: 12 | (B1 vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | struct B0 (primary base) +// CHECK-NEXT: 0 | (B0 vftable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (E vbtable pointer) +// CHECK-NEXT: 12 | struct B1 (virtual base) +// CHECK-NEXT: 12 | (B1 vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct E -// CHECK-X64: 0 | struct B0 (primary base) -// CHECK-X64: 0 | (B0 vftable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (E vbtable pointer) -// CHECK-X64: 24 | struct B1 (virtual base) -// CHECK-X64: 24 | (B1 vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | struct B0 (primary base) +// CHECK-X64-NEXT: 0 | (B0 vftable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | (E vbtable pointer) +// CHECK-X64-NEXT: 24 | struct B1 (virtual base) +// CHECK-X64-NEXT: 24 | (B1 vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct F : virtual B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | (F vbtable pointer) -// CHECK: 4 | struct B0 (virtual base) -// CHECK: 4 | (B0 vftable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct B1 (virtual base) -// CHECK: 12 | (B1 vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=4, nvalign=4] +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | (F vbtable pointer) +// CHECK-NEXT: 4 | struct B0 (virtual base) +// CHECK-NEXT: 4 | (B0 vftable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct B1 (virtual base) +// CHECK-NEXT: 12 | (B1 vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F -// CHECK-X64: 0 | (F vbtable pointer) -// CHECK-X64: 8 | struct B0 (virtual base) -// CHECK-X64: 8 | (B0 vftable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B1 (virtual base) -// CHECK-X64: 24 | (B1 vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 0 | struct F +// CHECK-X64-NEXT: 0 | (F vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B0 (virtual base) +// CHECK-X64-NEXT: 8 | (B0 vftable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B1 (virtual base) +// CHECK-X64-NEXT: 24 | (B1 vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] struct AX : B0X, B1X { int a; AX() : a(0xf000000A) {} virtual void f() { printf("A"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct AX -// CHECK: 8 | struct B0X (base) -// CHECK: 8 | int a -// CHECK: 0 | struct B1X (primary base) -// CHECK: 0 | (B1X vftable pointer) -// CHECK: 4 | int a -// CHECK: 12 | int a -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct AX +// CHECK-NEXT: 0 | struct B1X (primary base) +// CHECK-NEXT: 0 | (B1X vftable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0X (base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct AX -// CHECK-X64: 16 | struct B0X (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 0 | struct B1X (primary base) -// CHECK-X64: 0 | (B1X vftable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 20 | int a -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct AX +// CHECK-X64-NEXT: 0 | struct B1X (primary base) +// CHECK-X64-NEXT: 0 | (B1X vftable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0X (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct BX : B0X, B1X { int a; BX() : a(0xf000000B) {} virtual void g() { printf("B"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct BX -// CHECK: 8 | struct B0X (base) -// CHECK: 8 | int a -// CHECK: 0 | struct B1X (primary base) -// CHECK: 0 | (B1X vftable pointer) -// CHECK: 4 | int a -// CHECK: 12 | int a -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=16, nvalign=4] -// CHECK-x64: *** Dumping AST Record Layout -// CHECK-x64: 0 | struct BX -// CHECK-x64: 16 | struct B0X (base) -// CHECK-x64: 16 | int a -// CHECK-x64: 0 | struct B1X (primary base) -// CHECK-x64: 0 | (B1X vftable pointer) -// CHECK-x64: 8 | int a -// CHECK-x64: 24 | int a -// CHECK-x64: | [sizeof=24, align=8 -// CHECK-x64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct BX +// CHECK-NEXT: 0 | struct B1X (primary base) +// CHECK-NEXT: 0 | (B1X vftable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0X (base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=16, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct BX +// CHECK-X64-NEXT: 0 | struct B1X (primary base) +// CHECK-X64-NEXT: 0 | (B1X vftable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0X (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct CX : B0X, B2X { int a; CX() : a(0xf000000C) {} virtual void g() { printf("C"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct CX -// CHECK: 0 | (CX vftable pointer) -// CHECK: 4 | struct B0X (base) -// CHECK: 4 | int a -// CHECK: 8 | struct B2X (base) -// CHECK: 8 | (B2X vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | int a -// CHECK: 20 | struct B1X (virtual base) -// CHECK: 20 | (B1X vftable pointer) -// CHECK: 24 | int a -// CHECK: | [sizeof=28, align=4 -// CHECK: | nvsize=20, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct CX +// CHECK-NEXT: 0 | (CX vftable pointer) +// CHECK-NEXT: 4 | struct B0X (base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B2X (base) +// CHECK-NEXT: 8 | (B2X vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B1X (virtual base) +// CHECK-NEXT: 20 | (B1X vftable pointer) +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: | [sizeof=28, align=4 +// CHECK-NEXT: | nvsize=20, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct CX -// CHECK-X64: 0 | (CX vftable pointer) -// CHECK-X64: 8 | struct B0X (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B2X (base) -// CHECK-X64: 16 | (B2X vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | int a -// CHECK-X64: 40 | struct B1X (virtual base) -// CHECK-X64: 40 | (B1X vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=56, align=8 -// CHECK-X64: | nvsize=40, nvalign=8] +// CHECK-X64-NEXT: 0 | struct CX +// CHECK-X64-NEXT: 0 | (CX vftable pointer) +// CHECK-X64-NEXT: 8 | struct B0X (base) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B2X (base) +// CHECK-X64-NEXT: 16 | (B2X vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 40 | struct B1X (virtual base) +// CHECK-X64-NEXT: 40 | (B1X vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=56, align=8 +// CHECK-X64-NEXT: | nvsize=40, nvalign=8] struct DX : virtual B1X { int a; DX() : a(0xf000000D) {} virtual void f() { printf("D"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct DX -// CHECK: 0 | (DX vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | (vtordisp for vbase B1X) -// CHECK: 12 | struct B1X (virtual base) -// CHECK: 12 | (B1X vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct DX +// CHECK-NEXT: 0 | (DX vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (vtordisp for vbase B1X) +// CHECK-NEXT: 12 | struct B1X (virtual base) +// CHECK-NEXT: 12 | (B1X vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct DX -// CHECK-X64: 0 | (DX vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 20 | (vtordisp for vbase B1X) -// CHECK-X64: 24 | struct B1X (virtual base) -// CHECK-X64: 24 | (B1X vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct DX +// CHECK-X64-NEXT: 0 | (DX vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 20 | (vtordisp for vbase B1X) +// CHECK-X64-NEXT: 24 | struct B1X (virtual base) +// CHECK-X64-NEXT: 24 | (B1X vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct EX : virtual B1X { int a; EX() : a(0xf000000E) {} virtual void g() { printf("E"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct EX -// CHECK: 0 | (EX vftable pointer) -// CHECK: 4 | (EX vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct B1X (virtual base) -// CHECK: 12 | (B1X vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK-NEXT: 0 | struct EX +// CHECK-NEXT: 0 | (EX vftable pointer) +// CHECK-NEXT: 4 | (EX vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct B1X (virtual base) +// CHECK-NEXT: 12 | (B1X vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct EX -// CHECK-X64: 0 | (EX vftable pointer) -// CHECK-X64: 8 | (EX vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct B1X (virtual base) -// CHECK-X64: 24 | (B1X vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct EX +// CHECK-X64-NEXT: 0 | (EX vftable pointer) +// CHECK-X64-NEXT: 8 | (EX vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct B1X (virtual base) +// CHECK-X64-NEXT: 24 | (B1X vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct FX : virtual B1X { int a; FX() : a(0xf000000F) {} }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct FX -// CHECK: 0 | (FX vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B1X (virtual base) -// CHECK: 8 | (B1X vftable pointer) -// CHECK: 12 | int a -// CHECK: | [sizeof=16, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct FX +// CHECK-NEXT: 0 | (FX vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B1X (virtual base) +// CHECK-NEXT: 8 | (B1X vftable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: | [sizeof=16, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct FX -// CHECK-X64: 0 | (FX vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B1X (virtual base) -// CHECK-X64: 16 | (B1X vftable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: | [sizeof=32, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct FX +// CHECK-X64-NEXT: 0 | (FX vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B1X (virtual base) +// CHECK-X64-NEXT: 16 | (B1X vftable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: | [sizeof=32, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] int a[ sizeof(A)+ diff --git a/test/Layout/ms-x86-size-alignment-fail.cpp b/test/Layout/ms-x86-size-alignment-fail.cpp index f998ee12c8d1..7e975b0039e2 100644 --- a/test/Layout/ms-x86-size-alignment-fail.cpp +++ b/test/Layout/ms-x86-size-alignment-fail.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -11,108 +11,112 @@ struct __declspec(align(1)) B1 {}; struct A : virtual B0 {}; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | (A vbtable pointer) -// CHECK: 4 | struct B0 (virtual base) -// CHECK: 4 | char a -// CHECK: | [sizeof=5, align=4 -// CHECK: | nvsize=4, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | (A vbtable pointer) +// CHECK-NEXT: 4 | struct B0 (virtual base) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: | [sizeof=5, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct A -// CHECK-X64: 0 | (A vbtable pointer) -// CHECK-X64: 8 | struct B0 (virtual base) -// CHECK-X64: 8 | char a -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 0 | struct A +// CHECK-X64-NEXT: 0 | (A vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B0 (virtual base) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] struct __declspec(align(1)) B : virtual B0 {}; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | (B vbtable pointer) -// CHECK: 4 | struct B0 (virtual base) -// CHECK: 4 | char a -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=4, nvalign=4] +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | (B vbtable pointer) +// CHECK-NEXT: 4 | struct B0 (virtual base) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | (B vbtable pointer) -// CHECK-X64: 8 | struct B0 (virtual base) -// CHECK-X64: 8 | char a -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | (B vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B0 (virtual base) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] struct C : virtual B0 { int a; C() : a(0xC) {} }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | (C vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B0 (virtual base) -// CHECK: 8 | char a -// CHECK: | [sizeof=9, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | (C vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0 (virtual base) +// CHECK-NEXT: 8 | char a +// CHECK-NEXT: | [sizeof=9, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | (C vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (virtual base) -// CHECK-X64: 16 | char a -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | (C vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct D : virtual B0 { __declspec(align(1)) int a; D() : a(0xD) {} }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | (D vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B0 (virtual base) -// CHECK: 8 | char a -// CHECK: | [sizeof=12, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | (D vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B0 (virtual base) +// CHECK-NEXT: 8 | char a +// CHECK-NEXT: | [sizeof=12, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | (D vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B0 (virtual base) -// CHECK-X64: 16 | char a -// CHECK-X64: | [sizeof=24, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | (D vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B0 (virtual base) +// CHECK-X64-NEXT: 16 | char a +// CHECK-X64-NEXT: | [sizeof=24, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct E : virtual B0, virtual B1 {}; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | (E vbtable pointer) -// CHECK: 4 | struct B0 (virtual base) -// CHECK: 4 | char a -// CHECK: 5 | struct B1 (virtual base) (empty) -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=4, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | (E vbtable pointer) +// CHECK-NEXT: 4 | struct B0 (virtual base) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: 5 | struct B1 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct E -// CHECK-X64: 0 | (E vbtable pointer) -// CHECK-X64: 8 | struct B0 (virtual base) -// CHECK-X64: 8 | char a -// CHECK-X64: 9 | struct B1 (virtual base) (empty) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | (E vbtable pointer) +// CHECK-X64-NEXT: 8 | struct B0 (virtual base) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: 9 | struct B1 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] struct F { char a; virtual ~F(); }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | (F vftable pointer) -// CHECK: 4 | char a -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | (F vftable pointer) +// CHECK-NEXT: 4 | char a +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F -// CHECK-X64: 0 | (F vftable pointer) -// CHECK-X64: 8 | char a -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct F +// CHECK-X64-NEXT: 0 | (F vftable pointer) +// CHECK-X64-NEXT: 8 | char a +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] int a[ sizeof(A)+ diff --git a/test/Layout/ms-x86-vfvb-alignment.cpp b/test/Layout/ms-x86-vfvb-alignment.cpp index 8eea20959b0e..54f74ac16d10 100644 --- a/test/Layout/ms-x86-vfvb-alignment.cpp +++ b/test/Layout/ms-x86-vfvb-alignment.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -16,349 +16,361 @@ struct B6 { int a; B6() : a(0xf00000B6) {} virtual void f() { printf("B6"); } }; struct A : B0, virtual B1 { __declspec(align(16)) int a; A() : a(0xf000000A) {} virtual void f() { printf("A"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | (A vftable pointer) -// CHECK: 16 | struct B0 (base) -// CHECK: 16 | int a -// CHECK: 20 | (A vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct B1 (virtual base) -// CHECK: 64 | char a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=64, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | (A vftable pointer) +// CHECK-NEXT: 16 | struct B0 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | (A vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct B1 (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: 0 | struct A -// CHECK-X64: 0 | (A vftable pointer) -// CHECK-X64: 8 | struct B0 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (A vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B1 (virtual base) -// CHECK-X64: 48 | char a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct A +// CHECK-X64-NEXT: 0 | (A vftable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | (A vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct B1 (virtual base) +// CHECK-X64-NEXT: 64 | char a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct B : A, B2 { int a; B() : a(0xf000000B) {} virtual void f() { printf("B"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | struct A (primary base) -// CHECK: 0 | (A vftable pointer) -// CHECK: 16 | struct B0 (base) -// CHECK: 16 | int a -// CHECK: 20 | (A vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct B2 (base) -// CHECK: 64 | (B2 vbtable pointer) -// CHECK: 68 | int a -// CHECK: 72 | int a -// CHECK: 80 | struct B1 (virtual base) -// CHECK: 80 | char a -// CHECK: | [sizeof=96, align=16 -// CHECK: | nvsize=80, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | struct A (primary base) +// CHECK-NEXT: 0 | (A vftable pointer) +// CHECK-NEXT: 16 | struct B0 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | (A vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct B2 (base) +// CHECK-NEXT: 64 | (B2 vbtable pointer) +// CHECK-NEXT: 68 | int a +// CHECK-NEXT: 72 | int a +// CHECK-NEXT: 80 | struct B1 (virtual base) +// CHECK-NEXT: 80 | char a +// CHECK-NEXT: | [sizeof=96, align=16 +// CHECK-NEXT: | nvsize=80, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | struct A (primary base) -// CHECK-X64: 0 | (A vftable pointer) -// CHECK-X64: 8 | struct B0 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (A vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B2 (base) -// CHECK-X64: 48 | (B2 vbtable pointer) -// CHECK-X64: 56 | int a -// CHECK-X64: 64 | int a -// CHECK-X64: 80 | struct B1 (virtual base) -// CHECK-X64: 80 | char a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=80, nvalign=16] +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | struct A (primary base) +// CHECK-X64-NEXT: 0 | (A vftable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | (A vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct B2 (base) +// CHECK-X64-NEXT: 64 | (B2 vbtable pointer) +// CHECK-X64-NEXT: 72 | int a +// CHECK-X64-NEXT: 80 | int a +// CHECK-X64-NEXT: 96 | struct B1 (virtual base) +// CHECK-X64-NEXT: 96 | char a +// CHECK-X64-NEXT: | [sizeof=112, align=16 +// CHECK-X64-NEXT: | nvsize=96, nvalign=16] struct C : B4 { int a; C() : a(0xf000000C) {} virtual void f() { printf("C"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | (C vftable pointer) -// CHECK: 16 | struct B4 (base) -// CHECK: 16 | (B4 vbtable pointer) -// CHECK: 20 | int a -// CHECK: 24 | int a -// CHECK: 32 | struct B3 (virtual base) -// CHECK: 32 | int a -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=32, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | (C vftable pointer) +// CHECK-NEXT: 16 | struct B4 (base) +// CHECK-NEXT: 16 | (B4 vbtable pointer) +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: 32 | struct B3 (virtual base) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | (C vftable pointer) -// CHECK-X64: 16 | struct B4 (base) -// CHECK-X64: 16 | (B4 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B3 (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | (C vftable pointer) +// CHECK-X64-NEXT: 16 | struct B4 (base) +// CHECK-X64-NEXT: 16 | (B4 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 48 | struct B3 (virtual base) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct D : C { int a; D() : a(0xf000000D) {} virtual void f() { printf("D"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | struct C (primary base) -// CHECK: 0 | (C vftable pointer) -// CHECK: 16 | struct B4 (base) -// CHECK: 16 | (B4 vbtable pointer) -// CHECK: 20 | int a -// CHECK: 24 | int a -// CHECK: 32 | int a -// CHECK: 48 | struct B3 (virtual base) -// CHECK: 48 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | struct C (primary base) +// CHECK-NEXT: 0 | (C vftable pointer) +// CHECK-NEXT: 16 | struct B4 (base) +// CHECK-NEXT: 16 | (B4 vbtable pointer) +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 48 | struct B3 (virtual base) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=48, nvalign=16] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | struct C (primary base) -// CHECK-X64: 0 | (C vftable pointer) -// CHECK-X64: 16 | struct B4 (base) -// CHECK-X64: 16 | (B4 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | int a -// CHECK-X64: 64 | struct B3 (virtual base) -// CHECK-X64: 64 | int a -// CHECK-X64: | [sizeof=80, align=16 -// CHECK-X64: | nvsize=64, nvalign=16] +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | struct C (primary base) +// CHECK-X64-NEXT: 0 | (C vftable pointer) +// CHECK-X64-NEXT: 16 | struct B4 (base) +// CHECK-X64-NEXT: 16 | (B4 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct B3 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct E : virtual C { int a; E() : a(0xf000000E) {} virtual void f() { printf("E"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct E -// CHECK: 0 | (E vbtable pointer) -// CHECK: 4 | int a -// CHECK: 16 | struct B3 (virtual base) -// CHECK: 16 | int a -// CHECK: 44 | (vtordisp for vbase C) -// CHECK: 48 | struct C (virtual base) -// CHECK: 48 | (C vftable pointer) -// CHECK: 64 | struct B4 (base) -// CHECK: 64 | (B4 vbtable pointer) -// CHECK: 68 | int a -// CHECK: 72 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct E +// CHECK-NEXT: 0 | (E vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 16 | struct B3 (virtual base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 44 | (vtordisp for vbase C) +// CHECK-NEXT: 48 | struct C (virtual base) +// CHECK-NEXT: 48 | (C vftable pointer) +// CHECK-NEXT: 64 | struct B4 (base) +// CHECK-NEXT: 64 | (B4 vbtable pointer) +// CHECK-NEXT: 68 | int a +// CHECK-NEXT: 72 | int a +// CHECK-NEXT: | [sizeof=80, align=16 +// CHECK-NEXT: | nvsize=8, nvalign=16] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct E -// CHECK-X64: 0 | (E vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B3 (virtual base) -// CHECK-X64: 16 | int a -// CHECK-X64: 44 | (vtordisp for vbase C) -// CHECK-X64: 48 | struct C (virtual base) -// CHECK-X64: 48 | (C vftable pointer) -// CHECK-X64: 64 | struct B4 (base) -// CHECK-X64: 64 | (B4 vbtable pointer) -// CHECK-X64: 72 | int a -// CHECK-X64: 80 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct E +// CHECK-X64-NEXT: 0 | (E vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B3 (virtual base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 44 | (vtordisp for vbase C) +// CHECK-X64-NEXT: 48 | struct C (virtual base) +// CHECK-X64-NEXT: 48 | (C vftable pointer) +// CHECK-X64-NEXT: 64 | struct B4 (base) +// CHECK-X64-NEXT: 64 | (B4 vbtable pointer) +// CHECK-X64-NEXT: 72 | int a +// CHECK-X64-NEXT: 80 | int a +// CHECK-X64-NEXT: | [sizeof=96, align=16 +// CHECK-X64-NEXT: | nvsize=16, nvalign=16] struct F : B3, virtual B0 { int a; F() : a(0xf000000F) {} virtual void f() { printf("F"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct F -// CHECK: 0 | (F vftable pointer) -// CHECK: 16 | struct B3 (base) -// CHECK: 16 | int a -// CHECK: 32 | (F vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct B0 (virtual base) -// CHECK: 64 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=64, nvalign=16] +// CHECK-NEXT: 0 | struct F +// CHECK-NEXT: 0 | (F vftable pointer) +// CHECK-NEXT: 16 | struct B3 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | (F vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct B0 (virtual base) +// CHECK-NEXT: 64 | int a +// CHECK-NEXT: | [sizeof=80, align=16 +// CHECK-NEXT: | nvsize=64, nvalign=16] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct F -// CHECK-X64: 0 | (F vftable pointer) -// CHECK-X64: 16 | struct B3 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | (F vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 48 | struct B0 (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64-NEXT: 0 | struct F +// CHECK-X64-NEXT: 0 | (F vftable pointer) +// CHECK-X64-NEXT: 16 | struct B3 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | (F vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct B0 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct G : B2, B6, virtual B1 { int a; G() : a(0xf0000010) {} }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct G -// CHECK: 8 | struct B2 (base) -// CHECK: 8 | (B2 vbtable pointer) -// CHECK: 12 | int a -// CHECK: 0 | struct B6 (primary base) -// CHECK: 0 | (B6 vftable pointer) -// CHECK: 4 | int a -// CHECK: 16 | int a -// CHECK: 20 | struct B1 (virtual base) -// CHECK: 20 | char a -// CHECK: | [sizeof=21, align=4 -// CHECK: | nvsize=20, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct G +// CHECK-NEXT: 0 | struct B6 (primary base) +// CHECK-NEXT: 0 | (B6 vftable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B2 (base) +// CHECK-NEXT: 8 | (B2 vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B1 (virtual base) +// CHECK-NEXT: 20 | char a +// CHECK-NEXT: | [sizeof=21, align=4 +// CHECK-NEXT: | nvsize=20, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct G -// CHECK-X64: 16 | struct B2 (base) -// CHECK-X64: 16 | (B2 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 0 | struct B6 (primary base) -// CHECK-X64: 0 | (B6 vftable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 32 | int a -// CHECK-X64: 40 | struct B1 (virtual base) -// CHECK-X64: 40 | char a -// CHECK-X64: | [sizeof=48, align=8 -// CHECK-X64: | nvsize=40, nvalign=8] +// CHECK-X64-NEXT: 0 | struct G +// CHECK-X64-NEXT: 0 | struct B6 (primary base) +// CHECK-X64-NEXT: 0 | (B6 vftable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B2 (base) +// CHECK-X64-NEXT: 16 | (B2 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 40 | struct B1 (virtual base) +// CHECK-X64-NEXT: 40 | char a +// CHECK-X64-NEXT: | [sizeof=48, align=8 +// CHECK-X64-NEXT: | nvsize=40, nvalign=8] struct H : B6, B2, virtual B1 { int a; H() : a(0xf0000011) {} }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct H -// CHECK: 0 | struct B6 (primary base) -// CHECK: 0 | (B6 vftable pointer) -// CHECK: 4 | int a -// CHECK: 8 | struct B2 (base) -// CHECK: 8 | (B2 vbtable pointer) -// CHECK: 12 | int a -// CHECK: 16 | int a -// CHECK: 20 | struct B1 (virtual base) -// CHECK: 20 | char a -// CHECK: | [sizeof=21, align=4 -// CHECK: | nvsize=20, nvalign=4] +// CHECK-NEXT: 0 | struct H +// CHECK-NEXT: 0 | struct B6 (primary base) +// CHECK-NEXT: 0 | (B6 vftable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | struct B2 (base) +// CHECK-NEXT: 8 | (B2 vbtable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | struct B1 (virtual base) +// CHECK-NEXT: 20 | char a +// CHECK-NEXT: | [sizeof=21, align=4 +// CHECK-NEXT: | nvsize=20, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct H -// CHECK-X64: 0 | struct B6 (primary base) -// CHECK-X64: 0 | (B6 vftable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | struct B2 (base) -// CHECK-X64: 16 | (B2 vbtable pointer) -// CHECK-X64: 24 | int a -// CHECK-X64: 32 | int a -// CHECK-X64: 40 | struct B1 (virtual base) -// CHECK-X64: 40 | char a -// CHECK-X64: | [sizeof=48, align=8 -// CHECK-X64: | nvsize=40, nvalign=8] +// CHECK-X64-NEXT: 0 | struct H +// CHECK-X64-NEXT: 0 | struct B6 (primary base) +// CHECK-X64-NEXT: 0 | (B6 vftable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | struct B2 (base) +// CHECK-X64-NEXT: 16 | (B2 vbtable pointer) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 40 | struct B1 (virtual base) +// CHECK-X64-NEXT: 40 | char a +// CHECK-X64-NEXT: | [sizeof=48, align=8 +// CHECK-X64-NEXT: | nvsize=40, nvalign=8] struct I : B0, virtual B1 { int a; int a1; __declspec(align(16)) int a2; I() : a(0xf0000011), a1(0xf0000011), a2(0xf0000011) {} }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct I -// CHECK: 0 | struct B0 (base) -// CHECK: 0 | int a -// CHECK: 4 | (I vbtable pointer) -// CHECK: 20 | int a -// CHECK: 24 | int a1 -// CHECK: 32 | int a2 -// CHECK: 48 | struct B1 (virtual base) -// CHECK: 48 | char a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=48, nvalign=16] +// CHECK-NEXT: 0 | struct I +// CHECK-NEXT: 0 | struct B0 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 4 | (I vbtable pointer) +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: 24 | int a1 +// CHECK-NEXT: 32 | int a2 +// CHECK-NEXT: 48 | struct B1 (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 -// CHECK-X64: 0 | struct I -// CHECK-X64: 0 | struct B0 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 8 | (I vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 20 | int a1 -// CHECK-X64: 32 | int a2 -// CHECK-X64: 48 | struct B1 (virtual base) -// CHECK-X64: 48 | char a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64-NEXT: 0 | struct I +// CHECK-X64-NEXT: 0 | struct B0 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 8 | (I vbtable pointer) +// CHECK-X64-NEXT: 20 | int a +// CHECK-X64-NEXT: 24 | int a1 +// CHECK-X64-NEXT: 32 | int a2 +// CHECK-X64-NEXT: 48 | struct B1 (virtual base) +// CHECK-X64-NEXT: 48 | char a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct J : B0, B3, virtual B1 { int a; int a1; J() : a(0xf0000012), a1(0xf0000012) {} }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct J -// CHECK: 0 | struct B0 (base) -// CHECK: 0 | int a -// CHECK: 16 | struct B3 (base) -// CHECK: 16 | int a -// CHECK: 32 | (J vbtable pointer) -// CHECK: 48 | int a -// CHECK: 52 | int a1 -// CHECK: 64 | struct B1 (virtual base) -// CHECK: 64 | char a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=64, nvalign=16] +// CHECK-NEXT: 0 | struct J +// CHECK-NEXT: 0 | struct B0 (base) +// CHECK-NEXT: 0 | int a +// CHECK-NEXT: 16 | struct B3 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | (J vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 52 | int a1 +// CHECK-NEXT: 64 | struct B1 (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: 0 | struct J -// CHECK-X64: 0 | struct B0 (base) -// CHECK-X64: 0 | int a -// CHECK-X64: 16 | struct B3 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | (J vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 44 | int a1 -// CHECK-X64: 48 | struct B1 (virtual base) -// CHECK-X64: 48 | char a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64-NEXT: 0 | struct J +// CHECK-X64-NEXT: 0 | struct B0 (base) +// CHECK-X64-NEXT: 0 | int a +// CHECK-X64-NEXT: 16 | struct B3 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | (J vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 52 | int a1 +// CHECK-X64-NEXT: 64 | struct B1 (virtual base) +// CHECK-X64-NEXT: 64 | char a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct K { int a; K() : a(0xf0000013) {} virtual void f() { printf("K"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct K -// CHECK: 0 | (K vftable pointer) -// CHECK: 4 | int a -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct K +// CHECK-NEXT: 0 | (K vftable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct K -// CHECK-X64: 0 | (K vftable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct K +// CHECK-X64-NEXT: 0 | (K vftable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] struct L : virtual K { int a; L() : a(0xf0000014) {} virtual void g() { printf("L"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct L -// CHECK: 0 | (L vftable pointer) -// CHECK: 4 | (L vbtable pointer) -// CHECK: 8 | int a -// CHECK: 12 | struct K (virtual base) -// CHECK: 12 | (K vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=12, nvalign=4] +// CHECK-NEXT: 0 | struct L +// CHECK-NEXT: 0 | (L vftable pointer) +// CHECK-NEXT: 4 | (L vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 12 | struct K (virtual base) +// CHECK-NEXT: 12 | (K vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=12, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct L -// CHECK-X64: 0 | (L vftable pointer) -// CHECK-X64: 8 | (L vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 24 | struct K (virtual base) -// CHECK-X64: 24 | (K vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-X64-NEXT: 0 | struct L +// CHECK-X64-NEXT: 0 | (L vftable pointer) +// CHECK-X64-NEXT: 8 | (L vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | struct K (virtual base) +// CHECK-X64-NEXT: 24 | (K vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=24, nvalign=8] struct M : virtual K { int a; M() : a(0xf0000015) {} virtual void f() { printf("M"); } }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct M -// CHECK: 0 | (M vbtable pointer) -// CHECK: 4 | int a -// CHECK: 8 | (vtordisp for vbase K) -// CHECK: 12 | struct K (virtual base) -// CHECK: 12 | (K vftable pointer) -// CHECK: 16 | int a -// CHECK: | [sizeof=20, align=4 -// CHECK: | nvsize=8, nvalign=4] +// CHECK-NEXT: 0 | struct M +// CHECK-NEXT: 0 | (M vbtable pointer) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (vtordisp for vbase K) +// CHECK-NEXT: 12 | struct K (virtual base) +// CHECK-NEXT: 12 | (K vftable pointer) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: | [sizeof=20, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct M -// CHECK-X64: 0 | (M vbtable pointer) -// CHECK-X64: 8 | int a -// CHECK-X64: 20 | (vtordisp for vbase K) -// CHECK-X64: 24 | struct K (virtual base) -// CHECK-X64: 24 | (K vftable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: | [sizeof=40, align=8 -// CHECK-X64: | nvsize=16, nvalign=8] +// CHECK-X64-NEXT: 0 | struct M +// CHECK-X64-NEXT: 0 | (M vbtable pointer) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 20 | (vtordisp for vbase K) +// CHECK-X64-NEXT: 24 | struct K (virtual base) +// CHECK-X64-NEXT: 24 | (K vftable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=16, nvalign=8] int a[ sizeof(A)+ diff --git a/test/Layout/ms-x86-vfvb-sharing.cpp b/test/Layout/ms-x86-vfvb-sharing.cpp index 2b3d08e44c67..91f194f2a5e5 100644 --- a/test/Layout/ms-x86-vfvb-sharing.cpp +++ b/test/Layout/ms-x86-vfvb-sharing.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -18,27 +18,31 @@ struct A : B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | (A vftable pointer) -// CHECK: 16 | struct B0 (base) -// CHECK: 16 | int a -// CHECK: 20 | (A vbtable pointer) -// CHECK: 48 | int a -// CHECK: 64 | struct B1 (virtual base) -// CHECK: 64 | int a -// CHECK: | [sizeof=80, align=16 -// CHECK: | nvsize=64, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | (A vftable pointer) +// CHECK-NEXT: 16 | struct B0 (base) +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 20 | (A vbtable pointer) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: 64 | struct B1 (virtual base) +// CHECK-NEXT: 64 | int 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: 0 | struct A -// CHECK-X64: 0 | (A vftable pointer) -// CHECK-X64: 8 | struct B0 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (A vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B1 (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct A +// CHECK-X64-NEXT: 0 | (A vftable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 24 | (A vbtable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 64 | struct B1 (virtual base) +// CHECK-X64-NEXT: 64 | int a +// CHECK-X64-NEXT: | [sizeof=80, align=16 +// CHECK-X64-NEXT: | nvsize=64, nvalign=16] struct B : B2, B0, virtual B1 { __declspec(align(16)) int a; @@ -47,29 +51,31 @@ struct B : B2, B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct B -// CHECK: 0 | struct B2 (primary base) -// CHECK: 0 | (B2 vftable pointer) -// CHECK: 4 | struct B0 (base) -// CHECK: 4 | int a -// CHECK: 8 | (B vbtable pointer) -// CHECK: 32 | int a -// CHECK: 48 | struct B1 (virtual base) -// CHECK: 48 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=48, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct B +// CHECK-NEXT: 0 | struct B2 (primary base) +// CHECK-NEXT: 0 | (B2 vftable pointer) +// CHECK-NEXT: 4 | struct B0 (base) +// CHECK-NEXT: 4 | int a +// CHECK-NEXT: 8 | (B vbtable pointer) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 48 | struct B1 (virtual base) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=48, nvalign=16] // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct B -// CHECK-X64: 0 | struct B2 (primary base) -// CHECK-X64: 0 | (B2 vftable pointer) -// CHECK-X64: 8 | struct B0 (base) -// CHECK-X64: 8 | int a -// CHECK-X64: 16 | (B vbtable pointer) -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B1 (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct B +// CHECK-X64-NEXT: 0 | struct B2 (primary base) +// CHECK-X64-NEXT: 0 | (B2 vftable pointer) +// CHECK-X64-NEXT: 8 | struct B0 (base) +// CHECK-X64-NEXT: 8 | int a +// CHECK-X64-NEXT: 16 | (B vbtable pointer) +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 48 | struct B1 (virtual base) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct C : B3, B0, virtual B1 { __declspec(align(16)) int a; @@ -78,29 +84,31 @@ struct C : B3, B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | (C vftable pointer) -// CHECK: 16 | struct B3 (base) -// CHECK: 16 | (B3 vbtable pointer) -// CHECK: 20 | struct B0 (base) -// CHECK: 20 | int a -// CHECK: 32 | int a -// CHECK: 48 | struct B1 (virtual base) -// CHECK: 48 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=48, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | (C vftable pointer) +// CHECK-NEXT: 16 | struct B3 (base) +// CHECK-NEXT: 16 | (B3 vbtable pointer) +// CHECK-NEXT: 20 | struct B0 (base) +// CHECK-NEXT: 20 | int a +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: 48 | struct B1 (virtual base) +// CHECK-NEXT: 48 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=48, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | (C vftable pointer) -// CHECK-X64: 8 | struct B3 (base) -// CHECK-X64: 8 | (B3 vbtable pointer) -// CHECK-X64: 16 | struct B0 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B1 (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | (C vftable pointer) +// CHECK-X64-NEXT: 16 | struct B3 (base) +// CHECK-X64-NEXT: 16 | (B3 vbtable pointer) +// CHECK-X64-NEXT: 24 | struct B0 (base) +// CHECK-X64-NEXT: 24 | int a +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 48 | struct B1 (virtual base) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] struct D : B4, B0, virtual B1 { __declspec(align(16)) int a; @@ -109,29 +117,31 @@ struct D : B4, B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | struct B4 (primary base) -// CHECK: 0 | (B4 vftable pointer) -// CHECK: 4 | (B4 vbtable pointer) -// CHECK: 8 | struct B0 (base) -// CHECK: 8 | int a -// CHECK: 16 | int a -// CHECK: 32 | struct B1 (virtual base) -// CHECK: 32 | int a -// CHECK: | [sizeof=48, align=16 -// CHECK: | nvsize=32, nvalign=16] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | struct B4 (primary base) +// CHECK-NEXT: 0 | (B4 vftable pointer) +// CHECK-NEXT: 4 | (B4 vbtable pointer) +// CHECK-NEXT: 8 | struct B0 (base) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 16 | int a +// CHECK-NEXT: 32 | struct B1 (virtual base) +// CHECK-NEXT: 32 | int a +// CHECK-NEXT: | [sizeof=48, align=16 +// CHECK-NEXT: | nvsize=32, nvalign=16] +// CHECK-X64: *** Dumping AST Record Layout // CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | struct B4 (primary base) -// CHECK-X64: 0 | (B4 vftable pointer) -// CHECK-X64: 8 | (B4 vbtable pointer) -// CHECK-X64: 16 | struct B0 (base) -// CHECK-X64: 16 | int a -// CHECK-X64: 32 | int a -// CHECK-X64: 48 | struct B1 (virtual base) -// CHECK-X64: 48 | int a -// CHECK-X64: | [sizeof=64, align=16 -// CHECK-X64: | nvsize=48, nvalign=16] +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | struct B4 (primary base) +// CHECK-X64-NEXT: 0 | (B4 vftable pointer) +// CHECK-X64-NEXT: 8 | (B4 vbtable pointer) +// CHECK-X64-NEXT: 16 | struct B0 (base) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 32 | int a +// CHECK-X64-NEXT: 48 | struct B1 (virtual base) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: | [sizeof=64, align=16 +// CHECK-X64-NEXT: | nvsize=48, nvalign=16] int a[ sizeof(A)+ diff --git a/test/Layout/ms-x86-vtordisp.cpp b/test/Layout/ms-x86-vtordisp.cpp index b16f09ed704c..60779fb1975b 100644 --- a/test/Layout/ms-x86-vtordisp.cpp +++ b/test/Layout/ms-x86-vtordisp.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ +// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \ // RUN: | FileCheck %s -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ +// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ // RUN: | FileCheck %s -check-prefix CHECK-X64 extern "C" int printf(const char *fmt, ...); @@ -30,35 +30,39 @@ struct A : virtual B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct A -// CHECK: 0 | (A vftable pointer) -// CHECK: 4 | (A vbtable pointer) -// CHECK: 8 | int a -// CHECK: 16 | (vtordisp for vbase B0) -// CHECK: 20 | struct B0 (virtual base) -// CHECK: 20 | (B0 vftable pointer) -// CHECK: 24 | int a -// CHECK: 44 | (vtordisp for vbase B1) -// CHECK: 48 | struct B1 (virtual base) -// CHECK: 48 | (B1 vftable pointer) -// CHECK: 52 | int a -// CHECK: | [sizeof=64, align=16 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct A -// CHECK-X64: 0 | (A vftable pointer) -// CHECK-X64: 8 | (A vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 36 | (vtordisp for vbase B0) -// CHECK-X64: 40 | struct B0 (virtual base) -// CHECK-X64: 40 | (B0 vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: 76 | (vtordisp for vbase B1) -// CHECK-X64: 80 | struct B1 (virtual base) -// CHECK-X64: 80 | (B1 vftable pointer) -// CHECK-X64: 88 | int a -// CHECK-X64: | [sizeof=96, align=16 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct A +// CHECK-NEXT: 0 | (A vftable pointer) +// CHECK-NEXT: 4 | (A vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 16 | (vtordisp for vbase B0) +// CHECK-NEXT: 20 | struct B0 (virtual base) +// CHECK-NEXT: 20 | (B0 vftable pointer) +// CHECK-NEXT: 24 | int a +// CHECK-NEXT: 44 | (vtordisp for vbase B1) +// CHECK-NEXT: 48 | struct B1 (virtual base) +// CHECK-NEXT: 48 | (B1 vftable pointer) +// CHECK-NEXT: 52 | int a +// CHECK-NEXT: | [sizeof=64, align=16 +// CHECK-NEXT: | nvsize=12, 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 A +// CHECK-X64-NEXT: 0 | (A vftable pointer) +// CHECK-X64-NEXT: 8 | (A vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 36 | (vtordisp for vbase B0) +// CHECK-X64-NEXT: 40 | struct B0 (virtual base) +// CHECK-X64-NEXT: 40 | (B0 vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 76 | (vtordisp for vbase B1) +// CHECK-X64-NEXT: 80 | struct B1 (virtual base) +// CHECK-X64-NEXT: 80 | (B1 vftable pointer) +// CHECK-X64-NEXT: 88 | int a +// CHECK-X64-NEXT: | [sizeof=96, align=16 +// CHECK-X64-NEXT: | nvsize=24, nvalign=16] struct C : virtual B0, virtual B1, VAlign32 { int a; @@ -68,39 +72,43 @@ struct C : virtual B0, virtual B1, VAlign32 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct C -// CHECK: 0 | (C vftable pointer) -// CHECK: 32 | struct VAlign32 (base) -// CHECK: 32 | (VAlign32 vbtable pointer) -// CHECK: 36 | int a -// CHECK: 64 | (vtordisp for vbase B0) -// CHECK: 68 | struct B0 (virtual base) -// CHECK: 68 | (B0 vftable pointer) -// CHECK: 72 | int a -// CHECK: 108 | (vtordisp for vbase B1) -// CHECK: 112 | struct B1 (virtual base) -// CHECK: 112 | (B1 vftable pointer) -// CHECK: 116 | int a -// CHECK: 128 | struct Align32 (virtual base) (empty) -// CHECK: | [sizeof=128, align=32 -// CHECK: | nvsize=64, nvalign=32] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct C -// CHECK-X64: 0 | (C vftable pointer) -// CHECK-X64: 32 | struct VAlign32 (base) -// CHECK-X64: 32 | (VAlign32 vbtable pointer) -// CHECK-X64: 40 | int a -// CHECK-X64: 68 | (vtordisp for vbase B0) -// CHECK-X64: 72 | struct B0 (virtual base) -// CHECK-X64: 72 | (B0 vftable pointer) -// CHECK-X64: 80 | int a -// CHECK-X64: 108 | (vtordisp for vbase B1) -// CHECK-X64: 112 | struct B1 (virtual base) -// CHECK-X64: 112 | (B1 vftable pointer) -// CHECK-X64: 120 | int a -// CHECK-X64: 128 | struct Align32 (virtual base) (empty) -// CHECK-X64: | [sizeof=128, align=32 -// CHECK-X64: | nvsize=64, nvalign=32] +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct C +// CHECK-NEXT: 0 | (C vftable pointer) +// CHECK-NEXT: 32 | struct VAlign32 (base) +// CHECK-NEXT: 32 | (VAlign32 vbtable pointer) +// CHECK-NEXT: 36 | int a +// CHECK-NEXT: 64 | (vtordisp for vbase B0) +// CHECK-NEXT: 68 | struct B0 (virtual base) +// CHECK-NEXT: 68 | (B0 vftable pointer) +// CHECK-NEXT: 72 | int a +// CHECK-NEXT: 108 | (vtordisp for vbase B1) +// CHECK-NEXT: 112 | struct B1 (virtual base) +// CHECK-NEXT: 112 | (B1 vftable pointer) +// CHECK-NEXT: 116 | int a +// CHECK-NEXT: 128 | struct Align32 (virtual base) (empty) +// CHECK-NEXT: | [sizeof=128, align=32 +// CHECK-NEXT: | nvsize=64, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct C +// CHECK-X64-NEXT: 0 | (C vftable pointer) +// CHECK-X64-NEXT: 32 | struct VAlign32 (base) +// CHECK-X64-NEXT: 32 | (VAlign32 vbtable pointer) +// CHECK-X64-NEXT: 40 | int a +// CHECK-X64-NEXT: 68 | (vtordisp for vbase B0) +// CHECK-X64-NEXT: 72 | struct B0 (virtual base) +// CHECK-X64-NEXT: 72 | (B0 vftable pointer) +// CHECK-X64-NEXT: 80 | int a +// CHECK-X64-NEXT: 108 | (vtordisp for vbase B1) +// CHECK-X64-NEXT: 112 | struct B1 (virtual base) +// CHECK-X64-NEXT: 112 | (B1 vftable pointer) +// CHECK-X64-NEXT: 120 | int a +// CHECK-X64-NEXT: 128 | struct Align32 (virtual base) (empty) +// CHECK-X64-NEXT: | [sizeof=128, align=32 +// CHECK-X64-NEXT: | nvsize=64, nvalign=32] struct __declspec(align(32)) D : virtual B0, virtual B1 { int a; @@ -110,35 +118,35 @@ struct __declspec(align(32)) D : virtual B0, virtual B1 { }; // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct D -// CHECK: 0 | (D vftable pointer) -// CHECK: 4 | (D vbtable pointer) -// CHECK: 8 | int a -// CHECK: 32 | (vtordisp for vbase B0) -// CHECK: 36 | struct B0 (virtual base) -// CHECK: 36 | (B0 vftable pointer) -// CHECK: 40 | int a -// CHECK: 76 | (vtordisp for vbase B1) -// CHECK: 80 | struct B1 (virtual base) -// CHECK: 80 | (B1 vftable pointer) -// CHECK: 84 | int a -// CHECK: | [sizeof=96, align=32 -// CHECK: | nvsize=12, nvalign=4] -// CHECK-X64: *** Dumping AST Record Layout -// CHECK-X64: 0 | struct D -// CHECK-X64: 0 | (D vftable pointer) -// CHECK-X64: 8 | (D vbtable pointer) -// CHECK-X64: 16 | int a -// CHECK-X64: 36 | (vtordisp for vbase B0) -// CHECK-X64: 40 | struct B0 (virtual base) -// CHECK-X64: 40 | (B0 vftable pointer) -// CHECK-X64: 48 | int a -// CHECK-X64: 76 | (vtordisp for vbase B1) -// CHECK-X64: 80 | struct B1 (virtual base) -// CHECK-X64: 80 | (B1 vftable pointer) -// CHECK-X64: 88 | int a -// CHECK-X64: | [sizeof=96, align=32 -// CHECK-X64: | nvsize=24, nvalign=8] +// CHECK-NEXT: 0 | struct D +// CHECK-NEXT: 0 | (D vftable pointer) +// CHECK-NEXT: 4 | (D vbtable pointer) +// CHECK-NEXT: 8 | int a +// CHECK-NEXT: 32 | (vtordisp for vbase B0) +// CHECK-NEXT: 36 | struct B0 (virtual base) +// CHECK-NEXT: 36 | (B0 vftable pointer) +// CHECK-NEXT: 40 | int a +// CHECK-NEXT: 76 | (vtordisp for vbase B1) +// CHECK-NEXT: 80 | struct B1 (virtual base) +// CHECK-NEXT: 80 | (B1 vftable pointer) +// CHECK-NEXT: 84 | int a +// CHECK-NEXT: | [sizeof=96, align=32 +// CHECK-NEXT: | nvsize=12, nvalign=32] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct D +// CHECK-X64-NEXT: 0 | (D vftable pointer) +// CHECK-X64-NEXT: 8 | (D vbtable pointer) +// CHECK-X64-NEXT: 16 | int a +// CHECK-X64-NEXT: 36 | (vtordisp for vbase B0) +// CHECK-X64-NEXT: 40 | struct B0 (virtual base) +// CHECK-X64-NEXT: 40 | (B0 vftable pointer) +// CHECK-X64-NEXT: 48 | int a +// CHECK-X64-NEXT: 76 | (vtordisp for vbase B1) +// CHECK-X64-NEXT: 80 | struct B1 (virtual base) +// CHECK-X64-NEXT: 80 | (B1 vftable pointer) +// CHECK-X64-NEXT: 88 | int a +// CHECK-X64-NEXT: | [sizeof=96, align=32 +// CHECK-X64-NEXT: | nvsize=24, nvalign=32] struct AT { virtual ~AT(){} @@ -149,22 +157,275 @@ struct CT : virtual AT { CT::~CT(){} // CHECK: *** Dumping AST Record Layout -// CHECK: 0 | struct CT -// CHECK: 0 | (CT vbtable pointer) -// CHECK: 4 | struct AT (virtual base) -// CHECK: 4 | (AT vftable pointer) -// CHECK: | [sizeof=8, align=4 -// CHECK: | nvsize=4, nvalign=4] +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct CT +// CHECK-NEXT: 0 | (CT vbtable pointer) +// CHECK-NEXT: 4 | struct AT (virtual base) +// CHECK-NEXT: 4 | (AT vftable pointer) +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct CT +// CHECK-X64-NEXT: 0 | (CT vbtable pointer) +// CHECK-X64-NEXT: 8 | struct AT (virtual base) +// CHECK-X64-NEXT: 8 | (AT vftable pointer) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + +struct XA { + XA() { printf("XA"); } + long long ll; +}; +struct XB : XA { + XB() { printf("XB"); } + virtual void foo() {} + int b; +}; +struct XC : virtual XB { + XC() { printf("XC"); } + virtual void foo() {} +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct XC +// CHECK-NEXT: 0 | (XC vbtable pointer) +// CHECK-NEXT: 4 | (vtordisp for vbase XB) +// CHECK-NEXT: 8 | struct XB (virtual base) +// CHECK-NEXT: 8 | (XB vftable pointer) +// CHECK-NEXT: 16 | struct XA (base) +// CHECK-NEXT: 16 | long long ll +// CHECK-NEXT: 24 | int b +// CHECK-NEXT: | [sizeof=32, align=8 +// CHECK-NEXT: | nvsize=4, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct XC +// CHECK-X64-NEXT: 0 | (XC vbtable pointer) +// CHECK-X64-NEXT: 12 | (vtordisp for vbase XB) +// CHECK-X64-NEXT: 16 | struct XB (virtual base) +// CHECK-X64-NEXT: 16 | (XB vftable pointer) +// CHECK-X64-NEXT: 24 | struct XA (base) +// CHECK-X64-NEXT: 24 | long long ll +// CHECK-X64-NEXT: 32 | int b +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + +namespace pragma_test1 { +// No overrides means no vtordisps by default. +struct A { virtual ~A(); virtual void foo(); int a; }; +struct B : virtual A { virtual ~B(); virtual void bar(); int b; }; +struct C : virtual B { int c; }; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct pragma_test1::C +// CHECK-NEXT: 0 | (C vbtable pointer) +// CHECK-NEXT: 4 | int c +// CHECK-NEXT: 8 | struct pragma_test1::A (virtual base) +// CHECK-NEXT: 8 | (A vftable pointer) +// CHECK-NEXT: 12 | int a +// CHECK-NEXT: 16 | struct pragma_test1::B (virtual base) +// CHECK-NEXT: 16 | (B vftable pointer) +// CHECK-NEXT: 20 | (B vbtable pointer) +// CHECK-NEXT: 24 | int b +// CHECK-NEXT: | [sizeof=28, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +} + +namespace pragma_test2 { +struct A { virtual ~A(); virtual void foo(); int a; }; +#pragma vtordisp(push,2) +struct B : virtual A { virtual ~B(); virtual void bar(); int b; }; +struct C : virtual B { int c; }; +#pragma vtordisp(pop) +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct pragma_test2::C +// CHECK-NEXT: 0 | (C vbtable pointer) +// CHECK-NEXT: 4 | int c +// CHECK-NEXT: 8 | (vtordisp for vbase A) +// CHECK-NEXT: 12 | struct pragma_test2::A (virtual base) +// CHECK-NEXT: 12 | (A vftable pointer) +// CHECK-NEXT: 16 | int a +// By adding a virtual method and vftable to B, now we need a vtordisp. +// CHECK-NEXT: 20 | (vtordisp for vbase B) +// CHECK-NEXT: 24 | struct pragma_test2::B (virtual base) +// CHECK-NEXT: 24 | (B vftable pointer) +// CHECK-NEXT: 28 | (B vbtable pointer) +// CHECK-NEXT: 32 | int b +// CHECK-NEXT: | [sizeof=36, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +} + +namespace pragma_test3 { +struct A { virtual ~A(); virtual void foo(); int a; }; +#pragma vtordisp(push,2) +struct B : virtual A { virtual ~B(); virtual void foo(); int b; }; +struct C : virtual B { int c; }; +#pragma vtordisp(pop) +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct pragma_test3::C +// CHECK-NEXT: 0 | (C vbtable pointer) +// CHECK-NEXT: 4 | int c +// CHECK-NEXT: 8 | (vtordisp for vbase A) +// CHECK-NEXT: 12 | struct pragma_test3::A (virtual base) +// CHECK-NEXT: 12 | (A vftable pointer) +// CHECK-NEXT: 16 | int a +// No vtordisp before B! It doesn't have its own vftable. +// CHECK-NEXT: 20 | struct pragma_test3::B (virtual base) +// CHECK-NEXT: 20 | (B vbtable pointer) +// CHECK-NEXT: 24 | int b +// CHECK-NEXT: | [sizeof=28, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +} + +namespace pragma_test4 { +struct A { + A(); + virtual void foo(); + int a; +}; + +// Make sure the pragma applies to class template decls before they've been +// instantiated. +#pragma vtordisp(push,2) +template +struct B : virtual A { + B(); + virtual ~B(); + virtual void bar(); + T b; +}; +#pragma vtordisp(pop) + +struct C : virtual B { int c; }; +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct pragma_test4::C +// CHECK-NEXT: 0 | (C vbtable pointer) +// CHECK-NEXT: 4 | int c +// Pragma applies to B, which has vbase A. +// CHECK-NEXT: 8 | (vtordisp for vbase A) +// CHECK-NEXT: 12 | struct pragma_test4::A (virtual base) +// CHECK-NEXT: 12 | (A vftable pointer) +// CHECK-NEXT: 16 | int a +// Pragma does not apply to C, and B doesn't usually need a vtordisp in C. +// CHECK-NEXT: 20 | struct pragma_test4::B (virtual base) +// CHECK-NEXT: 20 | (B vftable pointer) +// CHECK-NEXT: 24 | (B vbtable pointer) +// CHECK-NEXT: 28 | int b +// CHECK-NEXT: | [sizeof=32, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +} + +struct GA { + virtual void fun() {} +}; +struct GB: public GA {}; +struct GC: public virtual GA { + virtual void fun() {} + GC() {} +}; +struct GD: public virtual GC, public virtual GB {}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct GD +// CHECK-NEXT: 0 | (GD vbtable pointer) +// CHECK-NEXT: 4 | (vtordisp for vbase GA) +// CHECK-NEXT: 8 | struct GA (virtual base) +// CHECK-NEXT: 8 | (GA vftable pointer) +// CHECK-NEXT: 12 | struct GC (virtual base) +// CHECK-NEXT: 12 | (GC vbtable pointer) +// CHECK-NEXT: 16 | struct GB (virtual base) +// CHECK-NEXT: 16 | struct GA (primary base) +// CHECK-NEXT: 16 | (GA vftable pointer) +// CHECK-NEXT: | [sizeof=20, 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: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct GD +// CHECK-X64-NEXT: 0 | (GD vbtable pointer) +// CHECK-X64-NEXT: 12 | (vtordisp for vbase GA) +// CHECK-X64-NEXT: 16 | struct GA (virtual base) +// CHECK-X64-NEXT: 16 | (GA vftable pointer) +// CHECK-X64-NEXT: 24 | struct GC (virtual base) +// CHECK-X64-NEXT: 24 | (GC vbtable pointer) +// CHECK-X64-NEXT: 32 | struct GB (virtual base) +// CHECK-X64-NEXT: 32 | struct GA (primary base) +// CHECK-X64-NEXT: 32 | (GA vftable pointer) +// CHECK-X64-NEXT: | [sizeof=40, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + +struct HA { + virtual void fun() {} +}; +#pragma vtordisp(push, 2) +struct HB : virtual HA {}; +#pragma vtordisp(pop) +#pragma vtordisp(push, 0) +struct HC : virtual HB {}; +#pragma vtordisp(pop) + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct HC +// CHECK-NEXT: 0 | (HC vbtable pointer) +// CHECK-NEXT: 4 | (vtordisp for vbase HA) +// CHECK-NEXT: 8 | struct HA (virtual base) +// CHECK-NEXT: 8 | (HA vftable pointer) +// CHECK-NEXT: 12 | struct HB (virtual base) +// CHECK-NEXT: 12 | (HB vbtable pointer) +// CHECK-NEXT: | [sizeof=16, 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: 0 | struct CT -// CHECK-X64: 0 | (CT vbtable pointer) -// CHECK-X64: 8 | struct AT (virtual base) -// CHECK-X64: 8 | (AT vftable pointer) -// CHECK-X64: | [sizeof=16, align=8 -// CHECK-X64: | nvsize=8, nvalign=8] +// CHECK-X64-NEXT: 0 | struct HC +// CHECK-X64-NEXT: 0 | (HC vbtable pointer) +// CHECK-X64-NEXT: 12 | (vtordisp for vbase HA) +// CHECK-X64-NEXT: 16 | struct HA (virtual base) +// CHECK-X64-NEXT: 16 | (HA vftable pointer) +// CHECK-X64-NEXT: 24 | struct HB (virtual base) +// CHECK-X64-NEXT: 24 | (HB vbtable pointer) +// CHECK-X64-NEXT: | [sizeof=32, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] int a[ sizeof(A)+ sizeof(C)+ sizeof(D)+ -sizeof(CT)]; +sizeof(CT)+ +sizeof(XC)+ +sizeof(pragma_test1::C)+ +sizeof(pragma_test2::C)+ +sizeof(pragma_test3::C)+ +sizeof(pragma_test4::C)+ +sizeof(GD)+ +sizeof(HC)+ +0]; -- cgit v1.3