| // RUN: %clang_cc1 -std=c++2a -fsyntax-only -triple x86_64-windows-msvc -fms-compatibility -fdump-record-layouts %s | FileCheck %s |
| |
| namespace Empty { |
| struct A {}; |
| struct A2 {}; |
| struct A3 { [[msvc::no_unique_address]] A a; }; |
| struct alignas(8) A4 {}; |
| |
| struct B { |
| [[msvc::no_unique_address]] A a; |
| char b; |
| }; |
| static_assert(sizeof(B) == 1); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::B |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: 0 | char b |
| // CHECK-NEXT: | [sizeof=1, align=1, |
| // CHECK-NEXT: | nvsize=1, nvalign=1] |
| |
| struct C { |
| [[msvc::no_unique_address]] A a; |
| [[msvc::no_unique_address]] A2 a2; |
| char c; |
| }; |
| static_assert(sizeof(C) == 1); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::C |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: 0 | struct Empty::A2 a2 (empty) |
| // CHECK-NEXT: 0 | char c |
| // CHECK-NEXT: | [sizeof=1, align=1, |
| // CHECK-NEXT: | nvsize=1, nvalign=1] |
| |
| struct D { |
| [[msvc::no_unique_address]] A3 a; |
| int i; |
| }; |
| static_assert(sizeof(D) == 8); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::D |
| // CHECK-NEXT: 0 | struct Empty::A3 a (empty) |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: 4 | int i |
| // CHECK-NEXT: | [sizeof=8, align=4, |
| // CHECK-NEXT: | nvsize=8, nvalign=4] |
| |
| struct E { |
| [[msvc::no_unique_address]] A a1; |
| [[msvc::no_unique_address]] A a2; |
| char e; |
| }; |
| static_assert(sizeof(E) == 2); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::E |
| // CHECK-NEXT: 0 | struct Empty::A a1 (empty) |
| // CHECK-NEXT: 1 | struct Empty::A a2 (empty) |
| // CHECK-NEXT: 0 | char e |
| // CHECK-NEXT: | [sizeof=2, align=1, |
| // CHECK-NEXT: | nvsize=2, nvalign=1] |
| |
| struct F { |
| ~F(); |
| [[msvc::no_unique_address]] A a1; |
| [[msvc::no_unique_address]] A a2; |
| char f; |
| }; |
| static_assert(sizeof(F) == 2); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::F |
| // CHECK-NEXT: 0 | struct Empty::A a1 (empty) |
| // CHECK-NEXT: 1 | struct Empty::A a2 (empty) |
| // CHECK-NEXT: 0 | char f |
| // CHECK-NEXT: | [sizeof=2, align=1, |
| // CHECK-NEXT: | nvsize=2, nvalign=1] |
| |
| struct G { [[msvc::no_unique_address]] A a; ~G(); }; |
| static_assert(sizeof(G) == 1); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::G |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: | [sizeof=1, align=1, |
| // CHECK-NEXT: | nvsize=1, nvalign=1] |
| |
| struct H { |
| [[msvc::no_unique_address]] A a; |
| [[msvc::no_unique_address]] A b; |
| ~H(); |
| }; |
| static_assert(sizeof(H) == 2); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::H |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: 1 | struct Empty::A b (empty) |
| // CHECK-NEXT: | [sizeof=2, align=1, |
| // CHECK-NEXT: | nvsize=2, nvalign=1] |
| |
| struct I { |
| [[msvc::no_unique_address]] A4 a; |
| [[msvc::no_unique_address]] A4 b; |
| }; |
| static_assert(sizeof(I) == 16); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::I |
| // CHECK-NEXT: 0 | struct Empty::A4 a (empty) |
| // CHECK-NEXT: 8 | struct Empty::A4 b (empty) |
| // CHECK-NEXT: | [sizeof=16, align=8, |
| // CHECK-NEXT: | nvsize=16, nvalign=8] |
| |
| struct J { |
| [[msvc::no_unique_address]] A4 a; |
| A4 b; |
| }; |
| static_assert(sizeof(J) == 16); |
| |
| // MSVC puts a and b at the same offset. |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::J |
| // CHECK-NEXT: 0 | struct Empty::A4 a (empty) |
| // CHECK-NEXT: 8 | struct Empty::A4 b (empty) |
| // CHECK-NEXT: | [sizeof=16, align=8, |
| // CHECK-NEXT: | nvsize=16, nvalign=8] |
| |
| struct K { |
| [[msvc::no_unique_address]] A4 a; |
| [[msvc::no_unique_address]] char c; |
| [[msvc::no_unique_address]] A4 b; |
| }; |
| static_assert(sizeof(K) == 16); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::K |
| // CHECK-NEXT: 0 | struct Empty::A4 a (empty) |
| // CHECK-NEXT: 0 | char c |
| // CHECK-NEXT: 8 | struct Empty::A4 b (empty) |
| // CHECK-NEXT: | [sizeof=16, align=8, |
| // CHECK-NEXT: | nvsize=16, nvalign=8] |
| |
| struct OversizedEmpty : A { |
| ~OversizedEmpty(); |
| [[msvc::no_unique_address]] A a; |
| }; |
| static_assert(sizeof(OversizedEmpty) == 1); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::OversizedEmpty |
| // CHECK-NEXT: 0 | struct Empty::A (base) (empty) |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: | [sizeof=1, align=1, |
| // CHECK-NEXT: | nvsize=1, nvalign=1] |
| |
| struct HasOversizedEmpty { |
| [[msvc::no_unique_address]] OversizedEmpty m; |
| }; |
| static_assert(sizeof(HasOversizedEmpty) == 1); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::HasOversizedEmpty |
| // CHECK-NEXT: 0 | struct Empty::OversizedEmpty m (empty) |
| // CHECK-NEXT: 0 | struct Empty::A (base) (empty) |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: | [sizeof=1, align=1, |
| // CHECK-NEXT: | nvsize=1, nvalign=1] |
| |
| struct EmptyWithNonzeroDSize { |
| [[msvc::no_unique_address]] A a; |
| int x; |
| [[msvc::no_unique_address]] A b; |
| int y; |
| [[msvc::no_unique_address]] A c; |
| }; |
| static_assert(sizeof(EmptyWithNonzeroDSize) == 8); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::EmptyWithNonzeroDSize |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: 0 | int x |
| // CHECK-NEXT: 1 | struct Empty::A b (empty) |
| // CHECK-NEXT: 4 | int y |
| // CHECK-NEXT: 2 | struct Empty::A c (empty) |
| // CHECK-NEXT: | [sizeof=8, align=4, |
| // CHECK-NEXT: | nvsize=8, nvalign=4] |
| |
| struct EmptyWithNonzeroDSizeNonPOD { |
| ~EmptyWithNonzeroDSizeNonPOD(); |
| [[msvc::no_unique_address]] A a; |
| int x; |
| [[msvc::no_unique_address]] A b; |
| int y; |
| [[msvc::no_unique_address]] A c; |
| }; |
| static_assert(sizeof(EmptyWithNonzeroDSizeNonPOD) == 8); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct Empty::EmptyWithNonzeroDSizeNonPOD |
| // CHECK-NEXT: 0 | struct Empty::A a (empty) |
| // CHECK-NEXT: 0 | int x |
| // CHECK-NEXT: 1 | struct Empty::A b (empty) |
| // CHECK-NEXT: 4 | int y |
| // CHECK-NEXT: 2 | struct Empty::A c (empty) |
| // CHECK-NEXT: | [sizeof=8, align=4, |
| // CHECK-NEXT: | nvsize=8, nvalign=4] |
| } |
| |
| namespace POD { |
| struct A { int n; char c[3]; }; |
| struct B { [[msvc::no_unique_address]] A a; char d; }; |
| static_assert(sizeof(B) == 12); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct POD::B |
| // CHECK-NEXT: 0 | struct POD::A a |
| // CHECK-NEXT: 0 | int n |
| // CHECK-NEXT: 4 | char[3] c |
| // CHECK-NEXT: 8 | char d |
| // CHECK-NEXT: | [sizeof=12, align=4, |
| // CHECK-NEXT: | nvsize=12, nvalign=4] |
| } |
| |
| namespace NonPOD { |
| struct A { int n; char c[3]; ~A(); }; |
| struct B { [[msvc::no_unique_address]] A a; char d; }; |
| static_assert(sizeof(B) == 12); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct NonPOD::B |
| // CHECK-NEXT: 0 | struct NonPOD::A a |
| // CHECK-NEXT: 0 | int n |
| // CHECK-NEXT: 4 | char[3] c |
| // CHECK-NEXT: 8 | char d |
| // CHECK-NEXT: | [sizeof=12, align=4, |
| // CHECK-NEXT: | nvsize=12, nvalign=4] |
| } |
| |
| namespace VBases { |
| // The nvsize of an object includes the complete size of its empty subobjects |
| // (although it's unclear why). Ensure this corner case is handled properly. |
| struct Empty {}; |
| struct alignas(8) A {}; // dsize 0, nvsize 0, size 8 |
| struct B : A { char c; }; // dsize 1, nvsize 8, size 8 |
| static_assert(sizeof(B) == 8); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct VBases::B |
| // CHECK-NEXT: 0 | struct VBases::A (base) (empty) |
| // CHECK-NEXT: 0 | char c |
| // CHECK-NEXT: | [sizeof=8, align=8, |
| // CHECK-NEXT: | nvsize=8, nvalign=8] |
| |
| struct V { int n; }; |
| |
| struct C : B, virtual V {}; |
| static_assert(sizeof(C) == 24); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct VBases::C |
| // CHECK-NEXT: 0 | struct VBases::B (base) |
| // CHECK-NEXT: 0 | struct VBases::A (base) (empty) |
| // CHECK-NEXT: 0 | char c |
| // CHECK-NEXT: 8 | (C vbtable pointer) |
| // CHECK-NEXT: 16 | struct VBases::V (virtual base) |
| // CHECK-NEXT: 16 | int n |
| // CHECK-NEXT: | [sizeof=24, align=8, |
| // CHECK-NEXT: | nvsize=16, nvalign=8] |
| |
| struct D : virtual Empty { |
| [[msvc::no_unique_address]] Empty a; |
| }; |
| static_assert(sizeof(D) == 16); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct VBases::D |
| // CHECK-NEXT: 0 | (D vbtable pointer) |
| // CHECK-NEXT: 8 | struct VBases::Empty a |
| // CHECK-NEXT: 16 | struct VBases::Empty (virtual base) (empty) |
| // CHECK-NEXT: | [sizeof=16, align=8, |
| // CHECK-NEXT: | nvsize=16, nvalign=8] |
| |
| struct E : virtual V { |
| [[msvc::no_unique_address]] B b; |
| }; |
| static_assert(sizeof(E) == 24); |
| |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct VBases::E |
| // CHECK-NEXT: 0 | (E vbtable pointer) |
| // CHECK-NEXT: 8 | struct VBases::B b |
| // CHECK-NEXT: 8 | struct VBases::A (base) (empty) |
| // CHECK-NEXT: 8 | char c |
| // CHECK-NEXT: 16 | struct VBases::V (virtual base) |
| // CHECK-NEXT: 16 | int n |
| // CHECK-NEXT: | [sizeof=24, align=8, |
| // CHECK-NEXT: | nvsize=16, nvalign=8] |
| |
| struct X : virtual A { [[msvc::no_unique_address]] A a; }; |
| struct F : virtual A { |
| [[msvc::no_unique_address]] A a; |
| [[msvc::no_unique_address]] X x; |
| }; |
| static_assert(sizeof(F) == 24); |
| |
| // MSVC places x after a and the total size is 48. |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct VBases::F |
| // CHECK-NEXT: 0 | (F vbtable pointer) |
| // CHECK-NEXT: 8 | struct VBases::A a (empty) |
| // CHECK-NEXT: 8 | struct VBases::X x |
| // CHECK-NEXT: 8 | (X vbtable pointer) |
| // CHECK-NEXT: 16 | struct VBases::A a (empty) |
| // CHECK-NEXT: 24 | struct VBases::A (virtual base) (empty) |
| // CHECK-NEXT: 24 | struct VBases::A (virtual base) (empty) |
| // CHECK-NEXT: | [sizeof=24, align=8, |
| // CHECK-NEXT: | nvsize=24, nvalign=8] |
| |
| struct G : virtual Empty { |
| int i; |
| [[msvc::no_unique_address]] A a; |
| }; |
| static_assert(sizeof(G) == 16); |
| |
| // MSVC places a at offset 12. |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct VBases::G |
| // CHECK-NEXT: 0 | (G vbtable pointer) |
| // CHECK-NEXT: 8 | int i |
| // CHECK-NEXT: 8 | struct VBases::A a (empty) |
| // CHECK-NEXT: 16 | struct VBases::Empty (virtual base) (empty) |
| // CHECK-NEXT: | [sizeof=16, align=8, |
| // CHECK-NEXT: | nvsize=16, nvalign=8] |
| } |
| |
| namespace ZeroSize { |
| struct empty {}; |
| |
| union empty_union {}; |
| |
| struct empty_union_container { |
| [[msvc::no_unique_address]] empty_union x; |
| }; |
| |
| union union_of_empty { |
| [[msvc::no_unique_address]] empty x; |
| }; |
| |
| struct struct_of_empty { |
| [[msvc::no_unique_address]] empty x; |
| }; |
| |
| struct union_of_empty_container { |
| [[msvc::no_unique_address]] union_of_empty x; |
| }; |
| static_assert(sizeof(union_of_empty_container) == 1); |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct ZeroSize::union_of_empty_container |
| // CHECK-NOT: (empty) |
| // CHECK: 0 | union ZeroSize::union_of_empty x (empty) |
| // CHECK: 0 | struct ZeroSize::empty x (empty) |
| // CHECK: | [sizeof=1, align=1, |
| // CHECK: | nvsize=1, nvalign=1] |
| |
| struct struct_of_empty_container { |
| [[msvc::no_unique_address]] struct_of_empty x; |
| }; |
| static_assert(sizeof(struct_of_empty_container) == 1); |
| // CHECK:*** Dumping AST Record Layout |
| // CHECK: 0 | struct ZeroSize::struct_of_empty_container |
| // CHECK-NOT: (empty) |
| // CHECK: 0 | struct ZeroSize::struct_of_empty x (empty) |
| // CHECK: 0 | struct ZeroSize::empty x (empty) |
| // CHECK: | [sizeof=1, align=1, |
| // CHECK: | nvsize=1, nvalign=1] |
| |
| } |
