test/SemaCXX/class-layout.cpp

   1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify -std=c++98 -Wno-inaccessible-base
   2 // RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify -std=c++11 -Wno-inaccessible-base
   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