Home | History | Annotate | Download | only in SemaCXX
      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