1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify 2 3 #define SA(n, p) int a##n[(p) ? 1 : -1] 4 5 namespace Test0 { 6 7 struct A { int a; }; 8 SA(0, sizeof(A) == 4); 9 10 struct B { }; 11 SA(1, sizeof(B) == 1); 12 13 struct C : A, B { }; 14 SA(2, sizeof(C) == 4); 15 16 struct D { }; 17 struct E : D { }; 18 struct F : E { }; 19 20 struct G : E, F { }; 21 SA(3, sizeof(G) == 2); 22 23 struct Empty { Empty(); }; 24 25 struct I : Empty { 26 Empty e; 27 }; 28 SA(4, sizeof(I) == 2); 29 30 struct J : Empty { 31 Empty e[2]; 32 }; 33 SA(5, sizeof(J) == 3); 34 35 template<int N> struct Derived : Empty, Derived<N - 1> { 36 }; 37 template<> struct Derived<0> : Empty { }; 38 39 struct S1 : virtual Derived<10> { 40 Empty e; 41 }; 42 SA(6, sizeof(S1) == 24); 43 44 struct S2 : virtual Derived<10> { 45 Empty e[2]; 46 }; 47 SA(7, sizeof(S2) == 24); 48 49 struct S3 { 50 Empty e; 51 }; 52 53 struct S4 : Empty, S3 { 54 }; 55 SA(8, sizeof(S4) == 2); 56 57 struct S5 : S3, Empty {}; 58 SA(9, sizeof(S5) == 2); 59 60 struct S6 : S5 { }; 61 SA(10, sizeof(S6) == 2); 62 63 struct S7 : Empty { 64 void *v; 65 }; 66 SA(11, sizeof(S7) == 8); 67 68 struct S8 : Empty, A { 69 }; 70 SA(12, sizeof(S8) == 4); 71 72 } 73 74 namespace Test1 { 75 76 // Test that we don't try to place both A subobjects at offset 0. 77 struct A { }; 78 class B { virtual void f(); }; 79 class C : A, virtual B { }; 80 struct D : virtual C { }; 81 struct E : virtual A { }; 82 class F : D, E { }; 83 84 SA(0, sizeof(F) == 24); 85 86 } 87 88 namespace Test2 { 89 90 // Test that B::a isn't laid out at offset 0. 91 struct Empty { }; 92 struct A : Empty { }; 93 struct B : Empty { 94 A a; 95 }; 96 97 SA(0, sizeof(B) == 2); 98 99 } 100 101 namespace Test3 { 102 103 // Test that B::a isn't laid out at offset 0. 104 struct Empty { }; 105 struct A { Empty e; }; 106 struct B : Empty { A a; }; 107 SA(0, sizeof(B) == 2); 108 109 } 110 111 namespace Test4 { 112 113 // Test that C::Empty isn't laid out at offset 0. 114 struct Empty { }; 115 struct A : Empty { }; 116 struct B { A a; }; 117 struct C : B, Empty { }; 118 SA(0, sizeof(C) == 2); 119 120 } 121 122 namespace Test5 { 123 124 // Test that B::Empty isn't laid out at offset 0. 125 struct Empty { }; 126 struct Field : virtual Empty { }; 127 struct A { 128 Field f; 129 }; 130 struct B : A, Empty { }; 131 SA(0, sizeof(B) == 16); 132 133 } 134 135 namespace Test6 { 136 137 // Test that B::A isn't laid out at offset 0. 138 struct Empty { }; 139 struct Field : virtual Empty { }; 140 struct A { 141 Field f; 142 }; 143 struct B : Empty, A { }; 144 SA(0, sizeof(B) == 16); 145 146 } 147 148 namespace Test7 { 149 // Make sure we reserve enough space for both bases; PR11745. 150 struct Empty { }; 151 struct Base1 : Empty { }; 152 struct Base2 : Empty { }; 153 struct Test : Base1, Base2 { 154 char c; 155 }; 156 SA(0, sizeof(Test) == 2); 157 } 158