1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify -std=c++98
2 // RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify -std=c++11
3 // expected-no-diagnostics
4 
5 #define SA(n, p) int a##n[(p) ? 1 : -1]
6 
7 struct A {
8   int a;
9   char b;
10 };
11 
12 SA(0, sizeof(A) == 8);
13 
14 struct B : A {
15   char c;
16 };
17 
18 SA(1, sizeof(B) == 12);
19 
20 struct C {
21 // Make fields private so C won't be a POD type.
22 private:
23   int a;
24   char b;
25 };
26 
27 SA(2, sizeof(C) == 8);
28 
29 struct D : C {
30   char c;
31 };
32 
33 SA(3, sizeof(D) == 8);
34 
35 struct __attribute__((packed)) E {
36   char b;
37   int a;
38 };
39 
40 SA(4, sizeof(E) == 5);
41 
42 struct __attribute__((packed)) F : E {
43   char d;
44 };
45 
46 SA(5, sizeof(F) == 6);
47 
48 struct G { G(); };
49 struct H : G { };
50 
51 SA(6, sizeof(H) == 1);
52 
53 struct I {
54   char b;
55   int a;
56 } __attribute__((packed));
57 
58 SA(6_1, sizeof(I) == 5);
59 
60 // PR5580
61 namespace PR5580 {
62 
63 class A { bool iv0 : 1; };
64 SA(7, sizeof(A) == 1);
65 
66 class B : A { bool iv0 : 1; };
67 SA(8, sizeof(B) == 2);
68 
69 struct C { bool iv0 : 1; };
70 SA(9, sizeof(C) == 1);
71 
72 struct D : C { bool iv0 : 1; };
73 SA(10, sizeof(D) == 2);
74 
75 }
76 
77 namespace Test1 {
78 
79 // Test that we don't assert on this hierarchy.
80 struct A { };
81 struct B : A { virtual void b(); };
82 class C : virtual A { int c; };
83 struct D : virtual B { };
84 struct E : C, virtual D { };
85 class F : virtual E { };
86 struct G : virtual E, F { };
87 
88 SA(0, sizeof(G) == 24);
89 
90 }
91 
92 namespace Test2 {
93 
94 // Test that this somewhat complex class structure is laid out correctly.
95 struct A { };
96 struct B : A { virtual void b(); };
97 struct C : virtual B { };
98 struct D : virtual A { };
99 struct E : virtual B, D { };
100 struct F : E, virtual C { };
101 struct G : virtual F, A { };
102 struct H { G g; };
103 
104 SA(0, sizeof(H) == 24);
105 
106 }
107 
108 namespace PR16537 {
109 namespace test1 {
110   struct pod_in_11_only {
111   private:
112     long long x;
113   };
114 
115   struct tail_padded_pod_in_11_only {
116     pod_in_11_only pod11;
117     char tail_padding;
118   };
119 
120   struct might_use_tail_padding : public tail_padded_pod_in_11_only {
121     char may_go_into_tail_padding;
122   };
123 
124   SA(0, sizeof(might_use_tail_padding) == 16);
125 }
126 
127 namespace test2 {
128   struct pod_in_11_only {
129   private:
130     long long x;
131   };
132 
133   struct tail_padded_pod_in_11_only {
134     pod_in_11_only pod11 __attribute__((aligned(16)));
135   };
136 
137   struct might_use_tail_padding : public tail_padded_pod_in_11_only {
138     char may_go_into_tail_padding;
139   };
140 
141   SA(0, sizeof(might_use_tail_padding) == 16);
142 }
143 
144 namespace test3 {
145   struct pod_in_11_only {
146   private:
147     long long x;
148   };
149 
150   struct tail_padded_pod_in_11_only {
151     pod_in_11_only pod11;
152     char tail_padding;
153   };
154 
155   struct second_base {
156       char foo;
157   };
158 
159   struct might_use_tail_padding : public tail_padded_pod_in_11_only, public second_base {
160 
161   };
162   SA(0, sizeof(might_use_tail_padding) == 16);
163 }
164 
165 namespace test4 {
166   struct pod_in_11_only {
167   private:
168     long long x;
169   };
170 
171   struct tail_padded_pod_in_11_only {
172     pod_in_11_only pod11;
173     char tail_padding;
174   };
175 
176   struct second_base {
177     char foo;
178   };
179 
180   struct might_use_tail_padding : public tail_padded_pod_in_11_only, public second_base {
181     char may_go_into_tail_padding;
182   };
183   SA(0, sizeof(might_use_tail_padding) == 16);
184 }
185 
186 namespace test5 {
187   struct pod_in_11_only {
188   private:
189     long long x;
190   };
191 
192   struct pod_in_11_only2 {
193   private:
194     long long x;
195   };
196 
197   struct tail_padded_pod_in_11_only {
198     pod_in_11_only pod11;
199     char tail_padding;
200   };
201 
202   struct second_base {
203     pod_in_11_only2 two;
204     char foo;
205   };
206 
207   struct might_use_tail_padding : public tail_padded_pod_in_11_only, public second_base {
208     char may_go_into_tail_padding;
209   };
210   SA(0, sizeof(might_use_tail_padding) == 32);
211 }
212 
213 namespace test6 {
214   struct pod_in_11_only {
215   private:
216     long long x;
217   };
218 
219   struct pod_in_11_only2 {
220   private:
221     long long x;
222   };
223 
224   struct tail_padded_pod_in_11_only {
225     pod_in_11_only pod11;
226     char tail_padding;
227   };
228 
229   struct second_base {
230     pod_in_11_only2 two;
231     char foo;
232   };
233 
234   struct might_use_tail_padding : public tail_padded_pod_in_11_only, public second_base {
235     char may_go_into_tail_padding;
236   };
237   SA(0, sizeof(might_use_tail_padding) == 32);
238 }
239 
240 namespace test7 {
241   struct pod_in_11_only {
242   private:
243     long long x;
244   };
245 
246   struct tail_padded_pod_in_11_only {
247     pod_in_11_only pod11;
248     pod_in_11_only pod12;
249     char tail_padding;
250   };
251 
252   struct might_use_tail_padding : public tail_padded_pod_in_11_only {
253     char may_go_into_tail_padding;
254   };
255 
256   SA(0, sizeof(might_use_tail_padding) == 24);
257 }
258 
259 namespace test8 {
260   struct pod_in_11_only {
261   private:
262     long long x;
263   };
264 
265   struct tail_padded_pod_in_11_only {
266     pod_in_11_only pod11;
267     char tail_padding;
268   };
269 
270   struct another_layer {
271     tail_padded_pod_in_11_only pod;
272     char padding;
273   };
274 
275   struct might_use_tail_padding : public another_layer {
276     char may_go_into_tail_padding;
277   };
278 
279   SA(0, sizeof(might_use_tail_padding) == 24);
280 }
281 
282 namespace test9 {
283   struct pod_in_11_only {
284   private:
285     long long x;
286   };
287 
288   struct tail_padded_pod_in_11_only {
289     pod_in_11_only pod11;
290     char tail_padding;
291   };
292 
293   struct another_layer : tail_padded_pod_in_11_only {
294   };
295 
296   struct might_use_tail_padding : public another_layer {
297     char may_go_into_tail_padding;
298   };
299 
300   SA(0, sizeof(might_use_tail_padding) == 16);
301 }
302 
303 namespace test10 {
304   struct pod_in_11_only {
305   private:
306     long long x;
307   };
308 
309   struct A {
310     pod_in_11_only a;
311     char apad;
312   };
313 
314   struct B {
315     char b;
316   };
317 
318   struct C {
319     pod_in_11_only c;
320     char cpad;
321   };
322 
323   struct D {
324     char d;
325   };
326 
327   struct might_use_tail_padding : public A, public B, public C, public D {
328   };
329 
330   SA(0, sizeof(might_use_tail_padding) == 32);
331 }
332 
333 namespace test11 {
334   struct pod_in_11_only {
335   private:
336     long long x;
337   };
338 
339   struct A {
340     pod_in_11_only a;
341     char apad;
342   };
343 
344   struct B {
345     char b_pre;
346     pod_in_11_only b;
347     char bpad;
348   };
349 
350   struct C {
351     char c_pre;
352     pod_in_11_only c;
353     char cpad;
354   };
355 
356   struct D {
357     char d_pre;
358     pod_in_11_only d;
359     char dpad;
360   };
361 
362   struct might_use_tail_padding : public A, public B, public C, public D {
363     char m;
364   };
365 
366   SA(0, sizeof(might_use_tail_padding) == 88);
367 }
368 
369 namespace test12 {
370   struct pod_in_11_only {
371   private:
372     long long x;
373   };
374 
375   struct A {
376     pod_in_11_only a __attribute__((aligned(128)));
377   };
378 
379   struct B {
380     char bpad;
381   };
382 
383   struct C {
384     char cpad;
385   };
386 
387   struct D {
388     char dpad;
389   };
390 
391   struct might_use_tail_padding : public A, public B, public C, public D {
392     char m;
393   };
394   SA(0, sizeof(might_use_tail_padding) == 128);
395 }
396 
397 namespace test13 {
398   struct pod_in_11_only {
399   private:
400     long long x;
401   };
402 
403   struct A {
404     pod_in_11_only a;
405     char apad;
406   };
407 
408   struct B {
409   };
410 
411   struct C {
412     char c_pre;
413     pod_in_11_only c;
414     char cpad;
415   };
416 
417   struct D {
418   };
419 
420   struct might_use_tail_padding : public A, public B, public C, public D {
421     char m;
422   };
423   SA(0, sizeof(might_use_tail_padding) == 40);
424 }
425 
426 namespace test14 {
427   struct pod_in_11_only {
428   private:
429     long long x;
430   };
431 
432   struct A {
433     pod_in_11_only a;
434     char apad;
435   };
436 
437   struct might_use_tail_padding : public A {
438     struct {
439       int : 0;
440     } x;
441   };
442   SA(0, sizeof(might_use_tail_padding) == 16);
443 }
444 
445 namespace test15 {
446   struct pod_in_11_only {
447   private:
448     long long x;
449   };
450 
451   struct A {
452     pod_in_11_only a;
453     char apad;
454   };
455 
456   struct might_use_tail_padding : public A {
457     struct {
458       char a:1;
459       char b:2;
460       char c:2;
461       char d:2;
462       char e:1;
463     } x;
464   };
465   SA(0, sizeof(might_use_tail_padding) == 16);
466 }
467 
468 namespace test16 {
469   struct pod_in_11_only {
470   private:
471     long long x;
472   };
473 
474   struct A  {
475     pod_in_11_only a;
476     char apad;
477   };
478 
479   struct B {
480     char bpod;
481     pod_in_11_only b;
482     char bpad;
483   };
484 
485   struct C : public A, public B {
486   };
487 
488   struct D : public C {
489   };
490 
491   struct might_use_tail_padding : public D {
492     char m;
493   };
494   SA(0, sizeof(might_use_tail_padding) == 40);
495 }
496 
497 namespace test17 {
498   struct pod_in_11_only {
499   private:
500     long long x;
501   };
502 
503   struct A {
504     pod_in_11_only a __attribute__((aligned(512)));
505   };
506 
507   struct B {
508     char bpad;
509     pod_in_11_only foo;
510     char btail;
511   };
512 
513   struct C {
514     char cpad;
515   };
516 
517   struct D {
518     char dpad;
519   };
520 
521   struct might_use_tail_padding : public A, public B, public C, public D {
522     char a;
523   };
524   SA(0, sizeof(might_use_tail_padding) == 512);
525 }
526 
527 namespace test18 {
528   struct pod_in_11_only {
529   private:
530     long long x;
531   };
532 
533   struct A  {
534     pod_in_11_only a;
535     char apad;
536   };
537 
538   struct B {
539     char bpod;
540     pod_in_11_only b;
541     char bpad;
542   };
543 
544   struct A1  {
545     pod_in_11_only a;
546     char apad;
547   };
548 
549   struct B1 {
550     char bpod;
551     pod_in_11_only b;
552     char bpad;
553   };
554 
555   struct C : public A, public B {
556   };
557 
558   struct D : public A1, public B1 {
559   };
560 
561   struct E : public D, public C {
562   };
563 
564   struct F : public E {
565   };
566 
567   struct might_use_tail_padding : public F {
568     char m;
569   };
570   SA(0, sizeof(might_use_tail_padding) == 80);
571 }
572 } // namespace PR16537
573