test/CodeGenCXX/vtable-layout.cpp

   1 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm-only -fdump-vtable-layouts > %t 2>&1
   2 // RUN: FileCheck --check-prefix=CHECK-1 %s < %t
   3 // RUN: FileCheck --check-prefix=CHECK-2 %s < %t
   4 // RUN: FileCheck --check-prefix=CHECK-3 %s < %t
   5 // RUN: FileCheck --check-prefix=CHECK-4 %s < %t
   6 // RUN: FileCheck --check-prefix=CHECK-5 %s < %t
   7 // RUN: FileCheck --check-prefix=CHECK-6 %s < %t
   8 // RUN: FileCheck --check-prefix=CHECK-7 %s < %t
   9 // RUN: FileCheck --check-prefix=CHECK-8 %s < %t
  10 // RUN: FileCheck --check-prefix=CHECK-9 %s < %t
  11 // RUN: FileCheck --check-prefix=CHECK-10 %s < %t
  12 // RUN: FileCheck --check-prefix=CHECK-11 %s < %t
  13 // RUN: FileCheck --check-prefix=CHECK-12 %s < %t
  14 // RUN: FileCheck --check-prefix=CHECK-13 %s < %t
  15 // RUN: FileCheck --check-prefix=CHECK-14 %s < %t
  16 // RUN: FileCheck --check-prefix=CHECK-15 %s < %t
  17 // RUN: FileCheck --check-prefix=CHECK-16 %s < %t
  18 // RUN: FileCheck --check-prefix=CHECK-17 %s < %t
  19 // RUN: FileCheck --check-prefix=CHECK-18 %s < %t
  20 // RUN: FileCheck --check-prefix=CHECK-19 %s < %t
  21 // RUN: FileCheck --check-prefix=CHECK-20 %s < %t
  22 // RUN: FileCheck --check-prefix=CHECK-21 %s < %t
  23 // RUN: FileCheck --check-prefix=CHECK-22 %s < %t
  24 // RUN: FileCheck --check-prefix=CHECK-23 %s < %t
  25 // RUN: FileCheck --check-prefix=CHECK-24 %s < %t
  26 // RUN: FileCheck --check-prefix=CHECK-25 %s < %t
  27 // RUN: FileCheck --check-prefix=CHECK-26 %s < %t
  28 // RUN: FileCheck --check-prefix=CHECK-27 %s < %t
  29 // RUN: FileCheck --check-prefix=CHECK-28 %s < %t
  30 // RUN: FileCheck --check-prefix=CHECK-29 %s < %t
  31 // RUN: FileCheck --check-prefix=CHECK-30 %s < %t
  32 // RUN: FileCheck --check-prefix=CHECK-31 %s < %t
  33 // RUN: FileCheck --check-prefix=CHECK-32 %s < %t
  34 // RUN: FileCheck --check-prefix=CHECK-33 %s < %t
  35 // RUN: FileCheck --check-prefix=CHECK-34 %s < %t
  36 // RUN: FileCheck --check-prefix=CHECK-35 %s < %t
  37 // RUN: FileCheck --check-prefix=CHECK-36 %s < %t
  38 // RUN: FileCheck --check-prefix=CHECK-37 %s < %t
  39 // RUN: FileCheck --check-prefix=CHECK-38 %s < %t
  40 // RUN: FileCheck --check-prefix=CHECK-39 %s < %t
  41 // RUN: FileCheck --check-prefix=CHECK-40 %s < %t
  42 // RUN: FileCheck --check-prefix=CHECK-41 %s < %t
  43 // RUN: FileCheck --check-prefix=CHECK-42 %s < %t
  44
  45 // For now, just verify this doesn't crash.
  46 namespace test0 {
  47   struct Obj {};
  48
  49   struct Base {           virtual const Obj *foo() = 0; };
  50   struct Derived : Base { virtual       Obj *foo() { return new Obj(); } };
  51
  52   void test(Derived *D) { D->foo(); }
  53 }
  54
  55 namespace Test1 {
  56 // CHECK-1:      Vtable for 'Test1::A' (3 entries).
  57 // CHECK-1-NEXT:   0 | offset_to_top (0)
  58 // CHECK-1-NEXT:   1 | Test1::A RTTI
  59 // CHECK-1-NEXT:       -- (Test1::A, 0) vtable address --
  60 // CHECK-1-NEXT:   2 | void Test1::A::f()
  61 struct A {
  62   virtual void f();
  63 };
  64 void A::f() { }
  65
  66 }
  67
  68 namespace Test2 {
  69
  70 // This is a smoke test of the vtable dumper.
  71 // CHECK-2:      Vtable for 'Test2::A' (9 entries).
  72 // CHECK-2-NEXT:   0 | offset_to_top (0)
  73 // CHECK-2-NEXT:   1 | Test2::A RTTI
  74 // CHECK-2-NEXT:       -- (Test2::A, 0) vtable address --
  75 // CHECK-2-NEXT:   2 | void Test2::A::f()
  76 // CHECK-2-NEXT:   3 | void Test2::A::f() const
  77 // CHECK-2-NEXT:   4 | Test2::A *Test2::A::g(int)
  78 // CHECK-2-NEXT:   5 | Test2::A::~A() [complete]
  79 // CHECK-2-NEXT:   6 | Test2::A::~A() [deleting]
  80 // CHECK-2-NEXT:   7 | void Test2::A::h()
  81 // CHECK-2-NEXT:   8 | Test2::A &Test2::A::operator=(const Test2::A &)
  82 struct A {
  83   virtual void f();
  84   virtual void f() const;
  85
  86   virtual A* g(int a);
  87   virtual ~A();
  88   virtual void h();
  89   virtual A& operator=(const A&);
  90 };
  91 void A::f() { }
  92
  93 // Another simple vtable dumper test.
  94
  95 // CHECK-3:     Vtable for 'Test2::B' (6 entries).
  96 // CHECK-3-NEXT:  0 | offset_to_top (0)
  97 // CHECK-3-NEXT:  1 | Test2::B RTTI
  98 // CHECK-3-NEXT:    -- (Test2::B, 0) vtable address --
  99 // CHECK-3-NEXT:  2 | void Test2::B::f()
 100 // CHECK-3-NEXT:  3 | void Test2::B::g() [pure]
 101 // CHECK-3-NEXT:  4 | Test2::B::~B() [complete] [pure]
 102 // CHECK-3-NEXT:  5 | Test2::B::~B() [deleting] [pure]
 103 struct B {
 104   virtual void f();
 105   virtual void g() = 0;
 106   virtual ~B() = 0;
 107 };
 108 void B::f() { }
 109
 110 }
 111
 112 namespace Test3 {
 113
 114 // If a function in a derived class overrides a function in a primary base,
 115 // then the function should not have an entry in the derived class (unless the return
 116 // value requires adjusting).
 117
 118 // CHECK-4:      Vtable for 'Test3::A' (3 entries).
 119 // CHECK-4-NEXT:   0 | offset_to_top (0)
 120 // CHECK-4-NEXT:   1 | Test3::A RTTI
 121 // CHECK-4-NEXT:       -- (Test3::A, 0) vtable address --
 122 // CHECK-4-NEXT:   2 | void Test3::A::f()
 123 struct A {
 124   virtual void f();
 125 };
 126 void A::f() { }
 127
 128 // CHECK-5:     Vtable for 'Test3::B' (4 entries).
 129 // CHECK-5-NEXT:  0 | offset_to_top (0)
 130 // CHECK-5-NEXT:  1 | Test3::B RTTI
 131 // CHECK-5-NEXT:      -- (Test3::A, 0) vtable address --
 132 // CHECK-5-NEXT:      -- (Test3::B, 0) vtable address --
 133 // CHECK-5-NEXT:  2 | void Test3::B::f()
 134 // CHECK-5-NEXT:  3 | void Test3::B::g()
 135 struct B : A {
 136   virtual void f();
 137   virtual void g();
 138 };
 139 void B::f() { }
 140
 141 // CHECK-6:     Vtable for 'Test3::C' (5 entries).
 142 // CHECK-6-NEXT:  0 | offset_to_top (0)
 143 // CHECK-6-NEXT:  1 | Test3::C RTTI
 144 // CHECK-6-NEXT:     -- (Test3::A, 0) vtable address --
 145 // CHECK-6-NEXT:     -- (Test3::C, 0) vtable address --
 146 // CHECK-6-NEXT:  2 | void Test3::A::f()
 147 // CHECK-6-NEXT:  3 | void Test3::C::g()
 148 // CHECK-6-NEXT:  4 | void Test3::C::h()
 149 struct C : A {
 150   virtual void g();
 151   virtual void h();
 152 };
 153 void C::g() { }
 154
 155 // CHECK-7:     Vtable for 'Test3::D' (5 entries).
 156 // CHECK-7-NEXT:  0 | offset_to_top (0)
 157 // CHECK-7-NEXT:  1 | Test3::D RTTI
 158 // CHECK-7-NEXT:     -- (Test3::A, 0) vtable address --
 159 // CHECK-7-NEXT:     -- (Test3::B, 0) vtable address --
 160 // CHECK-7-NEXT:     -- (Test3::D, 0) vtable address --
 161 // CHECK-7-NEXT:  2 | void Test3::D::f()
 162 // CHECK-7-NEXT:  3 | void Test3::D::g()
 163 // CHECK-7-NEXT:  4 | void Test3::D::h()
 164 struct D : B {
 165   virtual void f();
 166   virtual void g();
 167   virtual void h();
 168 };
 169
 170 void D::f() { }
 171 }
 172
 173 namespace Test4 {
 174
 175 // Test non-virtual result adjustments.
 176
 177 struct R1 { int r1; };
 178 struct R2 { int r2; };
 179 struct R3 : R1, R2 { int r3; };
 180
 181 struct A {
 182   virtual R2 *f();
 183 };
 184
 185 // CHECK-8:     Vtable for 'Test4::B' (4 entries).
 186 // CHECK-8-NEXT:  0 | offset_to_top (0)
 187 // CHECK-8-NEXT:  1 | Test4::B RTTI
 188 // CHECK-8-NEXT:      -- (Test4::A, 0) vtable address --
 189 // CHECK-8-NEXT:      -- (Test4::B, 0) vtable address --
 190 // CHECK-8-NEXT:  2 | Test4::R3 *Test4::B::f()
 191 // CHECK-8-NEXT:      [return adjustment: 4 non-virtual]
 192 // CHECK-8-NEXT:  3 | Test4::R3 *Test4::B::f()
 193
 194 struct B : A {
 195   virtual R3 *f();
 196 };
 197 R3 *B::f() { return 0; }
 198
 199 // Test virtual result adjustments.
 200 struct V1 { int v1; };
 201 struct V2 : virtual V1 { int v1; };
 202
 203 struct C {
 204   virtual V1 *f();
 205 };
 206
 207 // CHECK-9:     Vtable for 'Test4::D' (4 entries).
 208 // CHECK-9-NEXT:   0 | offset_to_top (0)
 209 // CHECK-9-NEXT:   1 | Test4::D RTTI
 210 // CHECK-9-NEXT:       -- (Test4::C, 0) vtable address --
 211 // CHECK-9-NEXT:       -- (Test4::D, 0) vtable address --
 212 // CHECK-9-NEXT:   2 | Test4::V2 *Test4::D::f()
 213 // CHECK-9-NEXT:       [return adjustment: 0 non-virtual, -24 vbase offset offset]
 214 // CHECK-9-NEXT:   3 | Test4::V2 *Test4::D::f()
 215 struct D : C {
 216   virtual V2 *f();
 217 };
 218 V2 *D::f() { return 0; };
 219
 220 // Virtual result adjustments with an additional non-virtual adjustment.
 221 struct V3 : virtual R3 { int r3; };
 222
 223 // CHECK-10:     Vtable for 'Test4::E' (4 entries).
 224 // CHECK-10-NEXT:   0 | offset_to_top (0)
 225 // CHECK-10-NEXT:   1 | Test4::E RTTI
 226 // CHECK-10-NEXT:       -- (Test4::A, 0) vtable address --
 227 // CHECK-10-NEXT:       -- (Test4::E, 0) vtable address --
 228 // CHECK-10-NEXT:   2 | Test4::V3 *Test4::E::f()
 229 // CHECK-10-NEXT:       [return adjustment: 4 non-virtual, -24 vbase offset offset]
 230 // CHECK-10-NEXT:   3 | Test4::V3 *Test4::E::f()
 231
 232 struct E : A {
 233   virtual V3 *f();
 234 };
 235 V3 *E::f() { return 0;}
 236
 237 // Test that a pure virtual member doesn't get a thunk.
 238
 239 // CHECK-11:     Vtable for 'Test4::F' (5 entries).
 240 // CHECK-11-NEXT:   0 | offset_to_top (0)
 241 // CHECK-11-NEXT:   1 | Test4::F RTTI
 242 // CHECK-11-NEXT:       -- (Test4::A, 0) vtable address --
 243 // CHECK-11-NEXT:       -- (Test4::F, 0) vtable address --
 244 // CHECK-11-NEXT:   2 | Test4::R3 *Test4::F::f() [pure]
 245 // CHECK-11-NEXT:   3 | void Test4::F::g()
 246 // CHECK-11-NEXT:   4 | Test4::R3 *Test4::F::f() [pure]
 247 struct F : A {
 248   virtual void g();
 249   virtual R3 *f() = 0;
 250 };
 251 void F::g() { }
 252
 253 }
 254
 255 namespace Test5 {
 256
 257 // Simple secondary vtables without 'this' pointer adjustments.
 258 struct A {
 259   virtual void f();
 260   virtual void g();
 261   int a;
 262 };
 263
 264 struct B1 : A {
 265   virtual void f();
 266   int b1;
 267 };
 268
 269 struct B2 : A {
 270   virtual void g();
 271   int b2;
 272 };
 273
 274 // CHECK-12:     Vtable for 'Test5::C' (9 entries).
 275 // CHECK-12-NEXT:   0 | offset_to_top (0)
 276 // CHECK-12-NEXT:   1 | Test5::C RTTI
 277 // CHECK-12-NEXT:       -- (Test5::A, 0) vtable address --
 278 // CHECK-12-NEXT:       -- (Test5::B1, 0) vtable address --
 279 // CHECK-12-NEXT:       -- (Test5::C, 0) vtable address --
 280 // CHECK-12-NEXT:   2 | void Test5::B1::f()
 281 // CHECK-12-NEXT:   3 | void Test5::A::g()
 282 // CHECK-12-NEXT:   4 | void Test5::C::h()
 283 // CHECK-12-NEXT:   5 | offset_to_top (-16)
 284 // CHECK-12-NEXT:   6 | Test5::C RTTI
 285 // CHECK-12-NEXT:       -- (Test5::A, 16) vtable address --
 286 // CHECK-12-NEXT:       -- (Test5::B2, 16) vtable address --
 287 // CHECK-12-NEXT:   7 | void Test5::A::f()
 288 // CHECK-12-NEXT:   8 | void Test5::B2::g()
 289 struct C : B1, B2 {
 290   virtual void h();
 291 };
 292 void C::h() { }
 293 }
 294
 295 namespace Test6 {
 296
 297 // Simple non-virtual 'this' pointer adjustments.
 298 struct A1 {
 299   virtual void f();
 300   int a;
 301 };
 302
 303 struct A2 {
 304   virtual void f();
 305   int a;
 306 };
 307
 308 // CHECK-13:     Vtable for 'Test6::C' (6 entries).
 309 // CHECK-13-NEXT:   0 | offset_to_top (0)
 310 // CHECK-13-NEXT:   1 | Test6::C RTTI
 311 // CHECK-13-NEXT:       -- (Test6::A1, 0) vtable address --
 312 // CHECK-13-NEXT:       -- (Test6::C, 0) vtable address --
 313 // CHECK-13-NEXT:   2 | void Test6::C::f()
 314 // CHECK-13-NEXT:   3 | offset_to_top (-16)
 315 // CHECK-13-NEXT:   4 | Test6::C RTTI
 316 // CHECK-13-NEXT:       -- (Test6::A2, 16) vtable address --
 317 // CHECK-13-NEXT:   5 | void Test6::C::f()
 318 // CHECK-13-NEXT:       [this adjustment: -16 non-virtual]
 319 struct C : A1, A2 {
 320   virtual void f();
 321 };
 322 void C::f() { }
 323
 324 }
 325
 326 namespace Test7 {
 327
 328 // Test that the D::f overrider for A::f have different 'this' pointer
 329 // adjustments in the two A base subobjects.
 330
 331 struct A {
 332   virtual void f();
 333   int a;
 334 };
 335
 336 struct B1 : A { };
 337 struct B2 : A { };
 338
 339 struct C { virtual void c(); };
 340
 341 // CHECK-14:     Vtable for 'Test7::D' (10 entries).
 342 // CHECK-14-NEXT:   0 | offset_to_top (0)
 343 // CHECK-14-NEXT:   1 | Test7::D RTTI
 344 // CHECK-14-NEXT:       -- (Test7::C, 0) vtable address --
 345 // CHECK-14-NEXT:       -- (Test7::D, 0) vtable address --
 346 // CHECK-14-NEXT:   2 | void Test7::C::c()
 347 // CHECK-14-NEXT:   3 | void Test7::D::f()
 348 // CHECK-14-NEXT:   4 | offset_to_top (-8)
 349 // CHECK-14-NEXT:   5 | Test7::D RTTI
 350 // CHECK-14-NEXT:       -- (Test7::A, 8) vtable address --
 351 // CHECK-14-NEXT:       -- (Test7::B1, 8) vtable address --
 352 // CHECK-14-NEXT:   6 | void Test7::D::f()
 353 // CHECK-14-NEXT:       [this adjustment: -8 non-virtual]
 354 // CHECK-14-NEXT:   7 | offset_to_top (-24)
 355 // CHECK-14-NEXT:   8 | Test7::D RTTI
 356 // CHECK-14-NEXT:       -- (Test7::A, 24) vtable address --
 357 // CHECK-14-NEXT:       -- (Test7::B2, 24) vtable address --
 358 // CHECK-14-NEXT:   9 | void Test7::D::f()
 359 // CHECK-14-NEXT:       [this adjustment: -24 non-virtual]
 360 struct D : C, B1, B2 {
 361   virtual void f();
 362 };
 363 void D::f() { }
 364
 365 }
 366
 367 namespace Test8 {
 368
 369 // Test that we don't try to layout vtables for classes that don't have
 370 // virtual bases or virtual member functions.
 371
 372 struct A { };
 373
 374 // CHECK-15:     Vtable for 'Test8::B' (3 entries).
 375 // CHECK-15-NEXT:   0 | offset_to_top (0)
 376 // CHECK-15-NEXT:   1 | Test8::B RTTI
 377 // CHECK-15-NEXT:       -- (Test8::B, 0) vtable address --
 378 // CHECK-15-NEXT:   2 | void Test8::B::f()
 379 struct B : A {
 380   virtual void f();
 381 };
 382 void B::f() { }
 383
 384 }
 385
 386 namespace Test9 {
 387
 388 // Simple test of vbase offsets.
 389
 390 struct A1 { int a1; };
 391 struct A2 { int a2; };
 392
 393 // CHECK-16:     Vtable for 'Test9::B' (5 entries).
 394 // CHECK-16-NEXT:   0 | vbase_offset (16)
 395 // CHECK-16-NEXT:   1 | vbase_offset (12)
 396 // CHECK-16-NEXT:   2 | offset_to_top (0)
 397 // CHECK-16-NEXT:   3 | Test9::B RTTI
 398 // CHECK-16-NEXT:       -- (Test9::B, 0) vtable address --
 399 // CHECK-16-NEXT:   4 | void Test9::B::f()
 400 struct B : virtual A1, virtual A2 {
 401   int b;
 402
 403   virtual void f();
 404 };
 405
 406
 407 void B::f() { }
 408
 409 }
 410
 411 namespace Test10 {
 412
 413 // Test for a bug where we would not emit secondary vtables for bases
 414 // of a primary base.
 415 struct A1 { virtual void a1(); };
 416 struct A2 { virtual void a2(); };
 417
 418 // CHECK-17:     Vtable for 'Test10::C' (7 entries).
 419 // CHECK-17-NEXT:   0 | offset_to_top (0)
 420 // CHECK-17-NEXT:   1 | Test10::C RTTI
 421 // CHECK-17-NEXT:       -- (Test10::A1, 0) vtable address --
 422 // CHECK-17-NEXT:       -- (Test10::B, 0) vtable address --
 423 // CHECK-17-NEXT:       -- (Test10::C, 0) vtable address --
 424 // CHECK-17-NEXT:   2 | void Test10::A1::a1()
 425 // CHECK-17-NEXT:   3 | void Test10::C::f()
 426 // CHECK-17-NEXT:   4 | offset_to_top (-8)
 427 // CHECK-17-NEXT:   5 | Test10::C RTTI
 428 // CHECK-17-NEXT:       -- (Test10::A2, 8) vtable address --
 429 // CHECK-17-NEXT:   6 | void Test10::A2::a2()
 430 struct B : A1, A2 {
 431   int b;
 432 };
 433
 434 struct C : B {
 435   virtual void f();
 436 };
 437 void C::f() { }
 438
 439 }
 440
 441 namespace Test11 {
 442
 443 // Very simple test of vtables for virtual bases.
 444 struct A1 { int a; };
 445 struct A2 { int b; };
 446
 447 struct B : A1, virtual A2 {
 448   int b;
 449 };
 450
 451 // CHECK-18:     Vtable for 'Test11::C' (8 entries).
 452 // CHECK-18-NEXT:   0 | vbase_offset (24)
 453 // CHECK-18-NEXT:   1 | vbase_offset (8)
 454 // CHECK-18-NEXT:   2 | offset_to_top (0)
 455 // CHECK-18-NEXT:   3 | Test11::C RTTI
 456 // CHECK-18-NEXT:       -- (Test11::C, 0) vtable address --
 457 // CHECK-18-NEXT:   4 | void Test11::C::f()
 458 // CHECK-18-NEXT:   5 | vbase_offset (16)
 459 // CHECK-18-NEXT:   6 | offset_to_top (-8)
 460 // CHECK-18-NEXT:   7 | Test11::C RTTI
 461 struct C : virtual B {
 462   virtual void f();
 463 };
 464 void C::f() { }
 465
 466 }
 467
 468 namespace Test12 {
 469
 470 // Test that the right vcall offsets are generated in the right order.
 471
 472 // CHECK-19:      Vtable for 'Test12::B' (19 entries).
 473 // CHECK-19-NEXT:    0 | vbase_offset (8)
 474 // CHECK-19-NEXT:    1 | offset_to_top (0)
 475 // CHECK-19-NEXT:    2 | Test12::B RTTI
 476 // CHECK-19-NEXT:        -- (Test12::B, 0) vtable address --
 477 // CHECK-19-NEXT:    3 | void Test12::B::f()
 478 // CHECK-19-NEXT:    4 | void Test12::B::a()
 479 // CHECK-19-NEXT:    5 | vcall_offset (32)
 480 // CHECK-19-NEXT:    6 | vcall_offset (16)
 481 // CHECK-19-NEXT:    7 | vcall_offset (-8)
 482 // CHECK-19-NEXT:    8 | vcall_offset (0)
 483 // CHECK-19-NEXT:    9 | offset_to_top (-8)
 484 // CHECK-19-NEXT:   10 | Test12::B RTTI
 485 // CHECK-19-NEXT:        -- (Test12::A, 8) vtable address --
 486 // CHECK-19-NEXT:        -- (Test12::A1, 8) vtable address --
 487 // CHECK-19-NEXT:   11 | void Test12::A1::a1()
 488 // CHECK-19-NEXT:   12 | void Test12::B::a()
 489 // CHECK-19-NEXT:        [this adjustment: 0 non-virtual, -32 vcall offset offset]
 490 // CHECK-19-NEXT:   13 | offset_to_top (-24)
 491 // CHECK-19-NEXT:   14 | Test12::B RTTI
 492 // CHECK-19-NEXT:        -- (Test12::A2, 24) vtable address --
 493 // CHECK-19-NEXT:   15 | void Test12::A2::a2()
 494 // CHECK-19-NEXT:   16 | offset_to_top (-40)
 495 // CHECK-19-NEXT:   17 | Test12::B RTTI
 496 // CHECK-19-NEXT:        -- (Test12::A3, 40) vtable address --
 497 // CHECK-19-NEXT:   18 | void Test12::A3::a3()
 498 struct A1 {
 499   virtual void a1();
 500   int a;
 501 };
 502
 503 struct A2 {
 504   virtual void a2();
 505   int a;
 506 };
 507
 508 struct A3 {
 509   virtual void a3();
 510   int a;
 511 };
 512
 513 struct A : A1, A2, A3 {
 514   virtual void a();
 515   int i;
 516 };
 517
 518 struct B : virtual A {
 519   virtual void f();
 520
 521   virtual void a();
 522 };
 523 void B::f() { }
 524
 525 }
 526
 527 namespace Test13 {
 528
 529 // Test that we don't try to emit a vtable for 'A' twice.
 530 struct A {
 531   virtual void f();
 532 };
 533
 534 struct B : virtual A {
 535   virtual void f();
 536 };
 537
 538 // CHECK-20:      Vtable for 'Test13::C' (6 entries).
 539 // CHECK-20-NEXT:    0 | vbase_offset (0)
 540 // CHECK-20-NEXT:    1 | vbase_offset (0)
 541 // CHECK-20-NEXT:    2 | vcall_offset (0)
 542 // CHECK-20-NEXT:    3 | offset_to_top (0)
 543 // CHECK-20-NEXT:    4 | Test13::C RTTI
 544 // CHECK-20-NEXT:        -- (Test13::A, 0) vtable address --
 545 // CHECK-20-NEXT:        -- (Test13::B, 0) vtable address --
 546 // CHECK-20-NEXT:        -- (Test13::C, 0) vtable address --
 547 // CHECK-20-NEXT:    5 | void Test13::C::f()
 548 struct C : virtual B, virtual A {
 549   virtual void f();
 550 };
 551 void C::f() { }
 552
 553 }
 554
 555 namespace Test14 {
 556
 557 // Verify that we handle A being a non-virtual base of B, which is a virtual base.
 558
 559 struct A {
 560   virtual void f();
 561 };
 562
 563 struct B : A { };
 564
 565 struct C : virtual B { };
 566
 567 // CHECK-21:      Vtable for 'Test14::D' (5 entries).
 568 // CHECK-21-NEXT:    0 | vbase_offset (0)
 569 // CHECK-21-NEXT:    1 | vcall_offset (0)
 570 // CHECK-21-NEXT:    2 | offset_to_top (0)
 571 // CHECK-21-NEXT:    3 | Test14::D RTTI
 572 // CHECK-21-NEXT:        -- (Test14::A, 0) vtable address --
 573 // CHECK-21-NEXT:        -- (Test14::B, 0) vtable address --
 574 // CHECK-21-NEXT:        -- (Test14::C, 0) vtable address --
 575 // CHECK-21-NEXT:        -- (Test14::D, 0) vtable address --
 576 // CHECK-21-NEXT:    4 | void Test14::D::f()
 577 struct D : C, virtual B {
 578  virtual void f();
 579 };
 580 void D::f() { }
 581
 582 }
 583
 584 namespace Test15 {
 585
 586 // Test that we don't emit an extra vtable for B since it's a primary base of C.
 587 struct A { virtual void a(); };
 588 struct B { virtual void b(); };
 589
 590 struct C : virtual B { };
 591
 592 // CHECK-22:      Vtable for 'Test15::D' (11 entries).
 593 // CHECK-22-NEXT:    0 | vbase_offset (8)
 594 // CHECK-22-NEXT:    1 | vbase_offset (8)
 595 // CHECK-22-NEXT:    2 | offset_to_top (0)
 596 // CHECK-22-NEXT:    3 | Test15::D RTTI
 597 // CHECK-22-NEXT:        -- (Test15::A, 0) vtable address --
 598 // CHECK-22-NEXT:        -- (Test15::D, 0) vtable address --
 599 // CHECK-22-NEXT:    4 | void Test15::A::a()
 600 // CHECK-22-NEXT:    5 | void Test15::D::f()
 601 // CHECK-22-NEXT:    6 | vbase_offset (0)
 602 // CHECK-22-NEXT:    7 | vcall_offset (0)
 603 // CHECK-22-NEXT:    8 | offset_to_top (-8)
 604 // CHECK-22-NEXT:    9 | Test15::D RTTI
 605 // CHECK-22-NEXT:        -- (Test15::B, 8) vtable address --
 606 // CHECK-22-NEXT:        -- (Test15::C, 8) vtable address --
 607 // CHECK-22-NEXT:   10 | void Test15::B::b()
 608 struct D : A, virtual B, virtual C {
 609   virtual void f();
 610 };
 611 void D::f() { }
 612
 613 }
 614
 615 namespace Test16 {
 616
 617 // Test that destructors share vcall offsets.
 618
 619 struct A { virtual ~A(); };
 620 struct B { virtual ~B(); };
 621
 622 struct C : A, B { virtual ~C(); };
 623
 624 // CHECK-23:      Vtable for 'Test16::D' (15 entries).
 625 // CHECK-23-NEXT:    0 | vbase_offset (8)
 626 // CHECK-23-NEXT:    1 | offset_to_top (0)
 627 // CHECK-23-NEXT:    2 | Test16::D RTTI
 628 // CHECK-23-NEXT:        -- (Test16::D, 0) vtable address --
 629 // CHECK-23-NEXT:    3 | void Test16::D::f()
 630 // CHECK-23-NEXT:    4 | Test16::D::~D() [complete]
 631 // CHECK-23-NEXT:    5 | Test16::D::~D() [deleting]
 632 // CHECK-23-NEXT:    6 | vcall_offset (-8)
 633 // CHECK-23-NEXT:    7 | offset_to_top (-8)
 634 // CHECK-23-NEXT:    8 | Test16::D RTTI
 635 // CHECK-23-NEXT:        -- (Test16::A, 8) vtable address --
 636 // CHECK-23-NEXT:        -- (Test16::C, 8) vtable address --
 637 // CHECK-23-NEXT:    9 | Test16::D::~D() [complete]
 638 // CHECK-23-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
 639 // CHECK-23-NEXT:   10 | Test16::D::~D() [deleting]
 640 // CHECK-23-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
 641 // CHECK-23-NEXT:   11 | offset_to_top (-16)
 642 // CHECK-23-NEXT:   12 | Test16::D RTTI
 643 // CHECK-23-NEXT:        -- (Test16::B, 16) vtable address --
 644 // CHECK-23-NEXT:   13 | Test16::D::~D() [complete]
 645 // CHECK-23-NEXT:        [this adjustment: -8 non-virtual, -24 vcall offset offset]
 646 // CHECK-23-NEXT:   14 | Test16::D::~D() [deleting]
 647 // CHECK-23-NEXT:        [this adjustment: -8 non-virtual, -24 vcall offset offset]
 648 struct D : virtual C {
 649   virtual void f();
 650 };
 651 void D::f() { }
 652
 653 }
 654
 655 namespace Test17 {
 656
 657 // Test that we don't mark E::f in the C-in-E vtable as unused.
 658 struct A { virtual void f(); };
 659 struct B : virtual A { virtual void f(); };
 660 struct C : virtual A { virtual void f(); };
 661 struct D : virtual B, virtual C { virtual void f(); };
 662
 663 // CHECK-24:      Vtable for 'Test17::E' (13 entries).
 664 // CHECK-24-NEXT:    0 | vbase_offset (0)
 665 // CHECK-24-NEXT:    1 | vbase_offset (8)
 666 // CHECK-24-NEXT:    2 | vbase_offset (0)
 667 // CHECK-24-NEXT:    3 | vbase_offset (0)
 668 // CHECK-24-NEXT:    4 | vcall_offset (0)
 669 // CHECK-24-NEXT:    5 | offset_to_top (0)
 670 // CHECK-24-NEXT:    6 | Test17::E RTTI
 671 // CHECK-24-NEXT:        -- (Test17::A, 0) vtable address --
 672 // CHECK-24-NEXT:        -- (Test17::B, 0) vtable address --
 673 // CHECK-24-NEXT:        -- (Test17::D, 0) vtable address --
 674 // CHECK-24-NEXT:        -- (Test17::E, 0) vtable address --
 675 // CHECK-24-NEXT:    7 | void Test17::E::f()
 676 // CHECK-24-NEXT:    8 | vbase_offset (-8)
 677 // CHECK-24-NEXT:    9 | vcall_offset (-8)
 678 // CHECK-24-NEXT:   10 | offset_to_top (-8)
 679 // CHECK-24-NEXT:   11 | Test17::E RTTI
 680 // CHECK-24-NEXT:        -- (Test17::C, 8) vtable address --
 681 // CHECK-24-NEXT:   12 | void Test17::E::f()
 682 // CHECK-24-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
 683 class E : virtual D {
 684   virtual void f();
 685 };
 686 void E::f() {}
 687
 688 }
 689
 690 namespace Test18 {
 691
 692 // Test that we compute the right 'this' adjustment offsets.
 693
 694 struct A {
 695   virtual void f();
 696   virtual void g();
 697 };
 698
 699 struct B : virtual A {
 700   virtual void f();
 701 };
 702
 703 struct C : A, B {
 704   virtual void g();
 705 };
 706
 707 // CHECK-25:      Vtable for 'Test18::D' (24 entries).
 708 // CHECK-25-NEXT:    0 | vbase_offset (8)
 709 // CHECK-25-NEXT:    1 | vbase_offset (0)
 710 // CHECK-25-NEXT:    2 | vbase_offset (0)
 711 // CHECK-25-NEXT:    3 | vcall_offset (8)
 712 // CHECK-25-NEXT:    4 | vcall_offset (0)
 713 // CHECK-25-NEXT:    5 | offset_to_top (0)
 714 // CHECK-25-NEXT:    6 | Test18::D RTTI
 715 // CHECK-25-NEXT:        -- (Test18::A, 0) vtable address --
 716 // CHECK-25-NEXT:        -- (Test18::B, 0) vtable address --
 717 // CHECK-25-NEXT:        -- (Test18::D, 0) vtable address --
 718 // CHECK-25-NEXT:    7 | void Test18::D::f()
 719 // CHECK-25-NEXT:    8 | void Test18::C::g()
 720 // CHECK-25-NEXT:        [this adjustment: 0 non-virtual, -32 vcall offset offset]
 721 // CHECK-25-NEXT:    9 | void Test18::D::h()
 722 // CHECK-25-NEXT:   10 | vcall_offset (0)
 723 // CHECK-25-NEXT:   11 | vcall_offset (-8)
 724 // CHECK-25-NEXT:   12 | vbase_offset (-8)
 725 // CHECK-25-NEXT:   13 | offset_to_top (-8)
 726 // CHECK-25-NEXT:   14 | Test18::D RTTI
 727 // CHECK-25-NEXT:        -- (Test18::A, 8) vtable address --
 728 // CHECK-25-NEXT:        -- (Test18::C, 8) vtable address --
 729 // CHECK-25-NEXT:   15 | void Test18::D::f()
 730 // CHECK-25-NEXT:        [this adjustment: 0 non-virtual, -32 vcall offset offset]
 731 // CHECK-25-NEXT:   16 | void Test18::C::g()
 732 // CHECK-25-NEXT:   17 | vbase_offset (-16)
 733 // CHECK-25-NEXT:   18 | vcall_offset (-8)
 734 // CHECK-25-NEXT:   19 | vcall_offset (-16)
 735 // CHECK-25-NEXT:   20 | offset_to_top (-16)
 736 // CHECK-25-NEXT:   21 | Test18::D RTTI
 737 // CHECK-25-NEXT:        -- (Test18::B, 16) vtable address --
 738 // CHECK-25-NEXT:   22 | void Test18::D::f()
 739 // CHECK-25-NEXT:        [this adjustment: -8 non-virtual, -32 vcall offset offset]
 740 // CHECK-25-NEXT:   23 | [unused] void Test18::C::g()
 741
 742 // CHECK-25:      Construction vtable for ('Test18::B', 0) in 'Test18::D' (7 entries).
 743 // CHECK-25-NEXT:    0 | vbase_offset (0)
 744 // CHECK-25-NEXT:    1 | vcall_offset (0)
 745 // CHECK-25-NEXT:    2 | vcall_offset (0)
 746 // CHECK-25-NEXT:    3 | offset_to_top (0)
 747 // CHECK-25-NEXT:    4 | Test18::B RTTI
 748 // CHECK-25-NEXT:        -- (Test18::A, 0) vtable address --
 749 // CHECK-25-NEXT:        -- (Test18::B, 0) vtable address --
 750 // CHECK-25-NEXT:    5 | void Test18::B::f()
 751 // CHECK-25-NEXT:    6 | void Test18::A::g()
 752
 753 // CHECK-25:      Construction vtable for ('Test18::C', 8) in 'Test18::D' (20 entries).
 754 // CHECK-25-NEXT:    0 | vcall_offset (0)
 755 // CHECK-25-NEXT:    1 | vcall_offset (0)
 756 // CHECK-25-NEXT:    2 | vbase_offset (-8)
 757 // CHECK-25-NEXT:    3 | offset_to_top (0)
 758 // CHECK-25-NEXT:    4 | Test18::C RTTI
 759 // CHECK-25-NEXT:        -- (Test18::A, 8) vtable address --
 760 // CHECK-25-NEXT:        -- (Test18::C, 8) vtable address --
 761 // CHECK-25-NEXT:    5 | void Test18::A::f()
 762 // CHECK-25-NEXT:    6 | void Test18::C::g()
 763 // CHECK-25-NEXT:    7 | vbase_offset (-16)
 764 // CHECK-25-NEXT:    8 | vcall_offset (-8)
 765 // CHECK-25-NEXT:    9 | vcall_offset (0)
 766 // CHECK-25-NEXT:   10 | offset_to_top (-8)
 767 // CHECK-25-NEXT:   11 | Test18::C RTTI
 768 // CHECK-25-NEXT:        -- (Test18::B, 16) vtable address --
 769 // CHECK-25-NEXT:   12 | void Test18::B::f()
 770 // CHECK-25-NEXT:   13 | [unused] void Test18::C::g()
 771 // CHECK-25-NEXT:   14 | vcall_offset (8)
 772 // CHECK-25-NEXT:   15 | vcall_offset (16)
 773 // CHECK-25-NEXT:   16 | offset_to_top (8)
 774 // CHECK-25-NEXT:   17 | Test18::C RTTI
 775 // CHECK-25-NEXT:        -- (Test18::A, 0) vtable address --
 776 // CHECK-25-NEXT:   18 | void Test18::B::f()
 777 // CHECK-25-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
 778 // CHECK-25-NEXT:   19 | void Test18::C::g()
 779 // CHECK-25-NEXT:        [this adjustment: 0 non-virtual, -32 vcall offset offset]
 780
 781 // CHECK-25:      Construction vtable for ('Test18::B', 16) in 'Test18::D' (13 entries).
 782 // CHECK-25-NEXT:    0 | vbase_offset (-16)
 783 // CHECK-25-NEXT:    1 | vcall_offset (-16)
 784 // CHECK-25-NEXT:    2 | vcall_offset (0)
 785 // CHECK-25-NEXT:    3 | offset_to_top (0)
 786 // CHECK-25-NEXT:    4 | Test18::B RTTI
 787 // CHECK-25-NEXT:        -- (Test18::B, 16) vtable address --
 788 // CHECK-25-NEXT:    5 | void Test18::B::f()
 789 // CHECK-25-NEXT:    6 | [unused] void Test18::A::g()
 790 // CHECK-25-NEXT:    7 | vcall_offset (0)
 791 // CHECK-25-NEXT:    8 | vcall_offset (16)
 792 // CHECK-25-NEXT:    9 | offset_to_top (16)
 793 // CHECK-25-NEXT:   10 | Test18::B RTTI
 794 // CHECK-25-NEXT:        -- (Test18::A, 0) vtable address --
 795 // CHECK-25-NEXT:   11 | void Test18::B::f()
 796 // CHECK-25-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
 797 // CHECK-25-NEXT:   12 | void Test18::A::g()
 798 struct D : virtual B, virtual C, virtual A
 799 {
 800   virtual void f();
 801   virtual void h();
 802 };
 803 void D::f() {}
 804
 805 }
 806
 807 namespace Test19 {
 808
 809 // Another 'this' adjustment test.
 810
 811 struct A {
 812   int a;
 813
 814   virtual void f();
 815 };
 816
 817 struct B : A {
 818   int b;
 819
 820   virtual void g();
 821 };
 822
 823 struct C {
 824   virtual void c();
 825 };
 826
 827 // CHECK-26:      Vtable for 'Test19::D' (13 entries).
 828 // CHECK-26-NEXT:    0 | vbase_offset (24)
 829 // CHECK-26-NEXT:    1 | offset_to_top (0)
 830 // CHECK-26-NEXT:    2 | Test19::D RTTI
 831 // CHECK-26-NEXT:        -- (Test19::C, 0) vtable address --
 832 // CHECK-26-NEXT:        -- (Test19::D, 0) vtable address --
 833 // CHECK-26-NEXT:    3 | void Test19::C::c()
 834 // CHECK-26-NEXT:    4 | void Test19::D::f()
 835 // CHECK-26-NEXT:    5 | offset_to_top (-8)
 836 // CHECK-26-NEXT:    6 | Test19::D RTTI
 837 // CHECK-26-NEXT:        -- (Test19::A, 8) vtable address --
 838 // CHECK-26-NEXT:        -- (Test19::B, 8) vtable address --
 839 // CHECK-26-NEXT:    7 | void Test19::D::f()
 840 // CHECK-26-NEXT:        [this adjustment: -8 non-virtual]
 841 // CHECK-26-NEXT:    8 | void Test19::B::g()
 842 // CHECK-26-NEXT:    9 | vcall_offset (-24)
 843 // CHECK-26-NEXT:   10 | offset_to_top (-24)
 844 // CHECK-26-NEXT:   11 | Test19::D RTTI
 845 // CHECK-26-NEXT:        -- (Test19::A, 24) vtable address --
 846 // CHECK-26-NEXT:   12 | void Test19::D::f()
 847 // CHECK-26-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
 848 struct D : C, B, virtual A {
 849   virtual void f();
 850 };
 851 void D::f() { }
 852
 853 }
 854
 855 namespace Test20 {
 856
 857 // pure virtual member functions should never have 'this' adjustments.
 858
 859 struct A {
 860   virtual void f() = 0;
 861   virtual void g();
 862 };
 863
 864 struct B : A { };
 865
 866 // CHECK-27:      Vtable for 'Test20::C' (9 entries).
 867 // CHECK-27-NEXT:    0 | offset_to_top (0)
 868 // CHECK-27-NEXT:    1 | Test20::C RTTI
 869 // CHECK-27-NEXT:        -- (Test20::A, 0) vtable address --
 870 // CHECK-27-NEXT:        -- (Test20::C, 0) vtable address --
 871 // CHECK-27-NEXT:    2 | void Test20::C::f() [pure]
 872 // CHECK-27-NEXT:    3 | void Test20::A::g()
 873 // CHECK-27-NEXT:    4 | void Test20::C::h()
 874 // CHECK-27-NEXT:    5 | offset_to_top (-8)
 875 // CHECK-27-NEXT:    6 | Test20::C RTTI
 876 // CHECK-27-NEXT:        -- (Test20::A, 8) vtable address --
 877 // CHECK-27-NEXT:        -- (Test20::B, 8) vtable address --
 878 // CHECK-27-NEXT:    7 | void Test20::C::f() [pure]
 879 // CHECK-27-NEXT:    8 | void Test20::A::g()
 880 struct C : A, B {
 881   virtual void f() = 0;
 882   virtual void h();
 883 };
 884 void C::h() { }
 885
 886 }
 887
 888 namespace Test21 {
 889
 890 // Test that we get vbase offsets right in secondary vtables.
 891 struct A {
 892   virtual void f();
 893 };
 894
 895 struct B : virtual A { };
 896 class C : virtual B { };
 897 class D : virtual C { };
 898
 899 class E : virtual C { };
 900
 901 // CHECK-28:      Vtable for 'Test21::F' (16 entries).
 902 // CHECK-28-NEXT:    0 | vbase_offset (8)
 903 // CHECK-28-NEXT:    1 | vbase_offset (0)
 904 // CHECK-28-NEXT:    2 | vbase_offset (0)
 905 // CHECK-28-NEXT:    3 | vbase_offset (0)
 906 // CHECK-28-NEXT:    4 | vbase_offset (0)
 907 // CHECK-28-NEXT:    5 | vcall_offset (0)
 908 // CHECK-28-NEXT:    6 | offset_to_top (0)
 909 // CHECK-28-NEXT:    7 | Test21::F RTTI
 910 // CHECK-28-NEXT:        -- (Test21::A, 0) vtable address --
 911 // CHECK-28-NEXT:        -- (Test21::B, 0) vtable address --
 912 // CHECK-28-NEXT:        -- (Test21::C, 0) vtable address --
 913 // CHECK-28-NEXT:        -- (Test21::D, 0) vtable address --
 914 // CHECK-28-NEXT:        -- (Test21::F, 0) vtable address --
 915 // CHECK-28-NEXT:    8 | void Test21::F::f()
 916 // CHECK-28-NEXT:    9 | vbase_offset (-8)
 917 // CHECK-28-NEXT:   10 | vbase_offset (-8)
 918 // CHECK-28-NEXT:   11 | vbase_offset (-8)
 919 // CHECK-28-NEXT:   12 | vcall_offset (-8)
 920 // CHECK-28-NEXT:   13 | offset_to_top (-8)
 921 // CHECK-28-NEXT:   14 | Test21::F RTTI
 922 // CHECK-28-NEXT:        -- (Test21::E, 8) vtable address --
 923 // CHECK-28-NEXT:   15 | [unused] void Test21::F::f()
 924 //
 925 // CHECK-28:      Virtual base offset offsets for 'Test21::F' (5 entries).
 926 // CHECK-28-NEXT:    Test21::A | -32
 927 // CHECK-28-NEXT:    Test21::B | -40
 928 // CHECK-28-NEXT:    Test21::C | -48
 929 // CHECK-28-NEXT:    Test21::D | -56
 930 // CHECK-28-NEXT:    Test21::E | -64
 931 class F : virtual D, virtual E {
 932   virtual void f();
 933 };
 934 void F::f() { }
 935
 936 }
 937
 938 namespace Test22 {
 939
 940 // Very simple construction vtable test.
 941 struct V1 {
 942   int v1;
 943 };
 944
 945 struct V2 : virtual V1 {
 946   int v2;
 947 };
 948
 949 // CHECK-29:      Vtable for 'Test22::C' (8 entries).
 950 // CHECK-29-NEXT:    0 | vbase_offset (16)
 951 // CHECK-29-NEXT:    1 | vbase_offset (12)
 952 // CHECK-29-NEXT:    2 | offset_to_top (0)
 953 // CHECK-29-NEXT:    3 | Test22::C RTTI
 954 // CHECK-29-NEXT:        -- (Test22::C, 0) vtable address --
 955 // CHECK-29-NEXT:    4 | void Test22::C::f()
 956 // CHECK-29-NEXT:    5 | vbase_offset (-4)
 957 // CHECK-29-NEXT:    6 | offset_to_top (-16)
 958 // CHECK-29-NEXT:    7 | Test22::C RTTI
 959 // CHECK-29-NEXT:        -- (Test22::V2, 16) vtable address --
 960
 961 // CHECK-29:      Construction vtable for ('Test22::V2', 16) in 'Test22::C' (3 entries).
 962 // CHECK-29-NEXT:    0 | vbase_offset (-4)
 963 // CHECK-29-NEXT:    1 | offset_to_top (0)
 964 // CHECK-29-NEXT:    2 | Test22::V2 RTTI
 965
 966 struct C : virtual V1, virtual V2 {
 967   int c;
 968   virtual void f();
 969 };
 970 void C::f() { }
 971
 972 }
 973
 974 namespace Test23 {
 975
 976 struct A {
 977   int a;
 978 };
 979
 980 struct B : virtual A {
 981   int b;
 982 };
 983
 984 struct C : A, virtual B {
 985   int c;
 986 };
 987
 988 // CHECK-30:      Vtable for 'Test23::D' (7 entries).
 989 // CHECK-30-NEXT:    0 | vbase_offset (20)
 990 // CHECK-30-NEXT:    1 | vbase_offset (24)
 991 // CHECK-30-NEXT:    2 | offset_to_top (0)
 992 // CHECK-30-NEXT:    3 | Test23::D RTTI
 993 // CHECK-30-NEXT:        -- (Test23::C, 0) vtable address --
 994 // CHECK-30-NEXT:        -- (Test23::D, 0) vtable address --
 995 // CHECK-30-NEXT:    4 | vbase_offset (-4)
 996 // CHECK-30-NEXT:    5 | offset_to_top (-24)
 997 // CHECK-30-NEXT:    6 | Test23::D RTTI
 998 // CHECK-30-NEXT:        -- (Test23::B, 24) vtable address --
 999
1000 // CHECK-30:      Construction vtable for ('Test23::C', 0) in 'Test23::D' (7 entries).
1001 // CHECK-30-NEXT:    0 | vbase_offset (20)
1002 // CHECK-30-NEXT:    1 | vbase_offset (24)
1003 // CHECK-30-NEXT:    2 | offset_to_top (0)
1004 // CHECK-30-NEXT:    3 | Test23::C RTTI
1005 // CHECK-30-NEXT:        -- (Test23::C, 0) vtable address --
1006 // CHECK-30-NEXT:    4 | vbase_offset (-4)
1007 // CHECK-30-NEXT:    5 | offset_to_top (-24)
1008 // CHECK-30-NEXT:    6 | Test23::C RTTI
1009 // CHECK-30-NEXT:        -- (Test23::B, 24) vtable address --
1010
1011 // CHECK-30:      Construction vtable for ('Test23::B', 24) in 'Test23::D' (3 entries).
1012 // CHECK-30-NEXT:    0 | vbase_offset (-4)
1013 // CHECK-30-NEXT:    1 | offset_to_top (0)
1014 // CHECK-30-NEXT:    2 | Test23::B RTTI
1015 // CHECK-30-NEXT:        -- (Test23::B, 24) vtable address --
1016
1017 struct D : virtual A, virtual B, C {
1018   int d;
1019
1020   void f();
1021 };
1022 void D::f() { }
1023   D d;
1024 }
1025
1026 namespace Test24 {
1027
1028 // Another construction vtable test.
1029
1030 struct A {
1031   virtual void f();
1032 };
1033
1034 struct B : virtual A { };
1035 struct C : virtual A { };
1036
1037 // CHECK-31:      Vtable for 'Test24::D' (10 entries).
1038 // CHECK-31-NEXT:    0 | vbase_offset (0)
1039 // CHECK-31-NEXT:    1 | vcall_offset (0)
1040 // CHECK-31-NEXT:    2 | offset_to_top (0)
1041 // CHECK-31-NEXT:    3 | Test24::D RTTI
1042 // CHECK-31-NEXT:        -- (Test24::A, 0) vtable address --
1043 // CHECK-31-NEXT:        -- (Test24::B, 0) vtable address --
1044 // CHECK-31-NEXT:        -- (Test24::D, 0) vtable address --
1045 // CHECK-31-NEXT:    4 | void Test24::D::f()
1046 // CHECK-31-NEXT:    5 | vbase_offset (-8)
1047 // CHECK-31-NEXT:    6 | vcall_offset (-8)
1048 // CHECK-31-NEXT:    7 | offset_to_top (-8)
1049 // CHECK-31-NEXT:    8 | Test24::D RTTI
1050 // CHECK-31-NEXT:        -- (Test24::C, 8) vtable address --
1051 // CHECK-31-NEXT:    9 | [unused] void Test24::D::f()
1052
1053 // CHECK-31:      Construction vtable for ('Test24::B', 0) in 'Test24::D' (5 entries).
1054 // CHECK-31-NEXT:    0 | vbase_offset (0)
1055 // CHECK-31-NEXT:    1 | vcall_offset (0)
1056 // CHECK-31-NEXT:    2 | offset_to_top (0)
1057 // CHECK-31-NEXT:    3 | Test24::B RTTI
1058 // CHECK-31-NEXT:        -- (Test24::A, 0) vtable address --
1059 // CHECK-31-NEXT:        -- (Test24::B, 0) vtable address --
1060 // CHECK-31-NEXT:    4 | void Test24::A::f()
1061
1062 // CHECK-31:      Construction vtable for ('Test24::C', 8) in 'Test24::D' (9 entries).
1063 // CHECK-31-NEXT:    0 | vbase_offset (-8)
1064 // CHECK-31-NEXT:    1 | vcall_offset (-8)
1065 // CHECK-31-NEXT:    2 | offset_to_top (0)
1066 // CHECK-31-NEXT:    3 | Test24::C RTTI
1067 // CHECK-31-NEXT:        -- (Test24::C, 8) vtable address --
1068 // CHECK-31-NEXT:    4 | [unused] void Test24::A::f()
1069 // CHECK-31-NEXT:    5 | vcall_offset (0)
1070 // CHECK-31-NEXT:    6 | offset_to_top (8)
1071 // CHECK-31-NEXT:    7 | Test24::C RTTI
1072 // CHECK-31-NEXT:        -- (Test24::A, 0) vtable address --
1073 // CHECK-31-NEXT:    8 | void Test24::A::f()
1074 struct D : B, C {
1075   virtual void f();
1076 };
1077 void D::f() { }
1078
1079 }
1080
1081 namespace Test25 {
1082
1083 // This mainly tests that we don't assert on this class hierarchy.
1084
1085 struct V {
1086   virtual void f();
1087 };
1088
1089 struct A : virtual V { };
1090 struct B : virtual V { };
1091
1092 // CHECK-32:      Vtable for 'Test25::C' (11 entries).
1093 // CHECK-32-NEXT:    0 | vbase_offset (0)
1094 // CHECK-32-NEXT:    1 | vcall_offset (0)
1095 // CHECK-32-NEXT:    2 | offset_to_top (0)
1096 // CHECK-32-NEXT:    3 | Test25::C RTTI
1097 // CHECK-32-NEXT:        -- (Test25::A, 0) vtable address --
1098 // CHECK-32-NEXT:        -- (Test25::C, 0) vtable address --
1099 // CHECK-32-NEXT:        -- (Test25::V, 0) vtable address --
1100 // CHECK-32-NEXT:    4 | void Test25::V::f()
1101 // CHECK-32-NEXT:    5 | void Test25::C::g()
1102 // CHECK-32-NEXT:    6 | vbase_offset (-8)
1103 // CHECK-32-NEXT:    7 | vcall_offset (-8)
1104 // CHECK-32-NEXT:    8 | offset_to_top (-8)
1105 // CHECK-32-NEXT:    9 | Test25::C RTTI
1106 // CHECK-32-NEXT:        -- (Test25::B, 8) vtable address --
1107 // CHECK-32-NEXT:   10 | [unused] void Test25::V::f()
1108
1109 // CHECK-32:      Construction vtable for ('Test25::A', 0) in 'Test25::C' (5 entries).
1110 // CHECK-32-NEXT:    0 | vbase_offset (0)
1111 // CHECK-32-NEXT:    1 | vcall_offset (0)
1112 // CHECK-32-NEXT:    2 | offset_to_top (0)
1113 // CHECK-32-NEXT:    3 | Test25::A RTTI
1114 // CHECK-32-NEXT:        -- (Test25::A, 0) vtable address --
1115 // CHECK-32-NEXT:        -- (Test25::V, 0) vtable address --
1116 // CHECK-32-NEXT:    4 | void Test25::V::f()
1117
1118 // CHECK-32:      Construction vtable for ('Test25::B', 8) in 'Test25::C' (9 entries).
1119 // CHECK-32-NEXT:    0 | vbase_offset (-8)
1120 // CHECK-32-NEXT:    1 | vcall_offset (-8)
1121 // CHECK-32-NEXT:    2 | offset_to_top (0)
1122 // CHECK-32-NEXT:    3 | Test25::B RTTI
1123 // CHECK-32-NEXT:        -- (Test25::B, 8) vtable address --
1124 // CHECK-32-NEXT:    4 | [unused] void Test25::V::f()
1125 // CHECK-32-NEXT:    5 | vcall_offset (0)
1126 // CHECK-32-NEXT:    6 | offset_to_top (8)
1127 // CHECK-32-NEXT:    7 | Test25::B RTTI
1128 // CHECK-32-NEXT:        -- (Test25::V, 0) vtable address --
1129 // CHECK-32-NEXT:    8 | void Test25::V::f()
1130 struct C : A, virtual V, B {
1131   virtual void g();
1132 };
1133 void C::g() { }
1134
1135 }
1136
1137 namespace Test26 {
1138
1139 // Test that we generate the right number of entries in the C-in-D construction vtable, and that
1140 // we don't mark A::a as unused.
1141
1142 struct A {
1143   virtual void a();
1144 };
1145
1146 struct B {
1147   virtual void c();
1148 };
1149
1150 struct C : virtual A {
1151   virtual void b();
1152 };
1153
1154 // CHECK-33:      Vtable for 'Test26::D' (15 entries).
1155 // CHECK-33-NEXT:    0 | vbase_offset (8)
1156 // CHECK-33-NEXT:    1 | vbase_offset (8)
1157 // CHECK-33-NEXT:    2 | vbase_offset (0)
1158 // CHECK-33-NEXT:    3 | vcall_offset (0)
1159 // CHECK-33-NEXT:    4 | offset_to_top (0)
1160 // CHECK-33-NEXT:    5 | Test26::D RTTI
1161 // CHECK-33-NEXT:        -- (Test26::B, 0) vtable address --
1162 // CHECK-33-NEXT:        -- (Test26::D, 0) vtable address --
1163 // CHECK-33-NEXT:    6 | void Test26::B::c()
1164 // CHECK-33-NEXT:    7 | void Test26::D::d()
1165 // CHECK-33-NEXT:    8 | vcall_offset (0)
1166 // CHECK-33-NEXT:    9 | vbase_offset (0)
1167 // CHECK-33-NEXT:   10 | vcall_offset (0)
1168 // CHECK-33-NEXT:   11 | offset_to_top (-8)
1169 // CHECK-33-NEXT:   12 | Test26::D RTTI
1170 // CHECK-33-NEXT:        -- (Test26::A, 8) vtable address --
1171 // CHECK-33-NEXT:        -- (Test26::C, 8) vtable address --
1172 // CHECK-33-NEXT:   13 | void Test26::A::a()
1173 // CHECK-33-NEXT:   14 | void Test26::C::b()
1174
1175 // CHECK-33:      Construction vtable for ('Test26::C', 8) in 'Test26::D' (7 entries).
1176 // CHECK-33-NEXT:    0 | vcall_offset (0)
1177 // CHECK-33-NEXT:    1 | vbase_offset (0)
1178 // CHECK-33-NEXT:    2 | vcall_offset (0)
1179 // CHECK-33-NEXT:    3 | offset_to_top (0)
1180 // CHECK-33-NEXT:    4 | Test26::C RTTI
1181 // CHECK-33-NEXT:        -- (Test26::A, 8) vtable address --
1182 // CHECK-33-NEXT:        -- (Test26::C, 8) vtable address --
1183 // CHECK-33-NEXT:    5 | void Test26::A::a()
1184 // CHECK-33-NEXT:    6 | void Test26::C::b()
1185 class D : virtual B, virtual C {
1186   virtual void d();
1187 };
1188 void D::d() { }
1189
1190 }
1191
1192 namespace Test27 {
1193
1194 // Test that we don't generate a secondary vtable for C in the D-in-E vtable, since
1195 // C doesn't have any virtual bases.
1196
1197 struct A {
1198   virtual void a();
1199 };
1200
1201 struct B {
1202   virtual void b();
1203 };
1204
1205 struct C {
1206   virtual void c();
1207 };
1208
1209 struct D : A, virtual B, C {
1210   virtual void d();
1211 };
1212
1213 // CHECK-34:      Vtable for 'Test27::E' (13 entries).
1214 // CHECK-34-NEXT:    0 | vbase_offset (16)
1215 // CHECK-34-NEXT:    1 | offset_to_top (0)
1216 // CHECK-34-NEXT:    2 | Test27::E RTTI
1217 // CHECK-34-NEXT:        -- (Test27::A, 0) vtable address --
1218 // CHECK-34-NEXT:        -- (Test27::D, 0) vtable address --
1219 // CHECK-34-NEXT:        -- (Test27::E, 0) vtable address --
1220 // CHECK-34-NEXT:    3 | void Test27::A::a()
1221 // CHECK-34-NEXT:    4 | void Test27::D::d()
1222 // CHECK-34-NEXT:    5 | void Test27::E::e()
1223 // CHECK-34-NEXT:    6 | offset_to_top (-8)
1224 // CHECK-34-NEXT:    7 | Test27::E RTTI
1225 // CHECK-34-NEXT:        -- (Test27::C, 8) vtable address --
1226 // CHECK-34-NEXT:    8 | void Test27::C::c()
1227 // CHECK-34-NEXT:    9 | vcall_offset (0)
1228 // CHECK-34-NEXT:   10 | offset_to_top (-16)
1229 // CHECK-34-NEXT:   11 | Test27::E RTTI
1230 // CHECK-34-NEXT:        -- (Test27::B, 16) vtable address --
1231 // CHECK-34-NEXT:   12 | void Test27::B::b()
1232
1233 // CHECK-34:      Construction vtable for ('Test27::D', 0) in 'Test27::E' (9 entries).
1234 // CHECK-34-NEXT:    0 | vbase_offset (16)
1235 // CHECK-34-NEXT:    1 | offset_to_top (0)
1236 // CHECK-34-NEXT:    2 | Test27::D RTTI
1237 // CHECK-34-NEXT:        -- (Test27::A, 0) vtable address --
1238 // CHECK-34-NEXT:        -- (Test27::D, 0) vtable address --
1239 // CHECK-34-NEXT:    3 | void Test27::A::a()
1240 // CHECK-34-NEXT:    4 | void Test27::D::d()
1241 // CHECK-34-NEXT:    5 | vcall_offset (0)
1242 // CHECK-34-NEXT:    6 | offset_to_top (-16)
1243 // CHECK-34-NEXT:    7 | Test27::D RTTI
1244 // CHECK-34-NEXT:        -- (Test27::B, 16) vtable address --
1245 // CHECK-34-NEXT:    8 | void Test27::B::b()
1246 struct E : D {
1247   virtual void e();
1248 };
1249 void E::e() { }
1250
1251 }
1252
1253 namespace Test28 {
1254
1255 // Check that we do include the vtable for B in the D-in-E construction vtable, since
1256 // B is a base class of a virtual base (C).
1257
1258 struct A {
1259   virtual void a();
1260 };
1261
1262 struct B {
1263   virtual void b();
1264 };
1265
1266 struct C : A, B {
1267   virtual void c();
1268 };
1269
1270 struct D : virtual C {
1271 };
1272
1273 // CHECK-35:      Vtable for 'Test28::E' (14 entries).
1274 // CHECK-35-NEXT:    0 | vbase_offset (8)
1275 // CHECK-35-NEXT:    1 | offset_to_top (0)
1276 // CHECK-35-NEXT:    2 | Test28::E RTTI
1277 // CHECK-35-NEXT:        -- (Test28::D, 0) vtable address --
1278 // CHECK-35-NEXT:        -- (Test28::E, 0) vtable address --
1279 // CHECK-35-NEXT:    3 | void Test28::E::e()
1280 // CHECK-35-NEXT:    4 | vcall_offset (8)
1281 // CHECK-35-NEXT:    5 | vcall_offset (0)
1282 // CHECK-35-NEXT:    6 | vcall_offset (0)
1283 // CHECK-35-NEXT:    7 | offset_to_top (-8)
1284 // CHECK-35-NEXT:    8 | Test28::E RTTI
1285 // CHECK-35-NEXT:        -- (Test28::A, 8) vtable address --
1286 // CHECK-35-NEXT:        -- (Test28::C, 8) vtable address --
1287 // CHECK-35-NEXT:    9 | void Test28::A::a()
1288 // CHECK-35-NEXT:   10 | void Test28::C::c()
1289 // CHECK-35-NEXT:   11 | offset_to_top (-16)
1290 // CHECK-35-NEXT:   12 | Test28::E RTTI
1291 // CHECK-35-NEXT:        -- (Test28::B, 16) vtable address --
1292 // CHECK-35-NEXT:   13 | void Test28::B::b()
1293
1294 // CHECK-35:      Construction vtable for ('Test28::D', 0) in 'Test28::E' (13 entries).
1295 // CHECK-35-NEXT:    0 | vbase_offset (8)
1296 // CHECK-35-NEXT:    1 | offset_to_top (0)
1297 // CHECK-35-NEXT:    2 | Test28::D RTTI
1298 // CHECK-35-NEXT:        -- (Test28::D, 0) vtable address --
1299 // CHECK-35-NEXT:    3 | vcall_offset (8)
1300 // CHECK-35-NEXT:    4 | vcall_offset (0)
1301 // CHECK-35-NEXT:    5 | vcall_offset (0)
1302 // CHECK-35-NEXT:    6 | offset_to_top (-8)
1303 // CHECK-35-NEXT:    7 | Test28::D RTTI
1304 // CHECK-35-NEXT:        -- (Test28::A, 8) vtable address --
1305 // CHECK-35-NEXT:        -- (Test28::C, 8) vtable address --
1306 // CHECK-35-NEXT:    8 | void Test28::A::a()
1307 // CHECK-35-NEXT:    9 | void Test28::C::c()
1308 // CHECK-35-NEXT:   10 | offset_to_top (-16)
1309 // CHECK-35-NEXT:   11 | Test28::D RTTI
1310 // CHECK-35-NEXT:        -- (Test28::B, 16) vtable address --
1311 // CHECK-35-NEXT:   12 | void Test28::B::b()
1312 struct E : D {
1313   virtual void e();
1314 };
1315 void E::e() { }
1316
1317 }
1318
1319 namespace Test29 {
1320
1321 // Test that the covariant return thunk for B::f will have a virtual 'this' adjustment,
1322 // matching gcc.
1323
1324 struct V1 { };
1325 struct V2 : virtual V1 { };
1326
1327 struct A {
1328   virtual V1 *f();
1329 };
1330
1331 // CHECK-36:      Vtable for 'Test29::B' (6 entries).
1332 // CHECK-36-NEXT:    0 | vbase_offset (0)
1333 // CHECK-36-NEXT:    1 | vcall_offset (0)
1334 // CHECK-36-NEXT:    2 | offset_to_top (0)
1335 // CHECK-36-NEXT:    3 | Test29::B RTTI
1336 // CHECK-36-NEXT:        -- (Test29::A, 0) vtable address --
1337 // CHECK-36-NEXT:        -- (Test29::B, 0) vtable address --
1338 // CHECK-36-NEXT:    4 | Test29::V2 *Test29::B::f()
1339 // CHECK-36-NEXT:        [return adjustment: 0 non-virtual, -24 vbase offset offset]
1340 // CHECK-36-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
1341 // CHECK-36-NEXT:    5 | Test29::V2 *Test29::B::f()
1342 struct B : virtual A {
1343   virtual V2 *f();
1344 };
1345 V2 *B::f() { return 0; }
1346
1347 }
1348
1349 namespace Test30 {
1350
1351 // Test that we don't assert when generating a vtable for F.
1352 struct A { };
1353
1354 struct B : virtual A {
1355  int i;
1356 };
1357
1358 struct C {
1359  virtual void f();
1360 };
1361
1362 struct D : virtual C, B { };
1363 struct E : virtual D { };
1364
1365 struct F : E {
1366  virtual void f();
1367 };
1368 void F::f() { }
1369
1370 }
1371
1372 namespace Test31 {
1373
1374 // Test that we don't add D::f twice to the primary vtable.
1375 struct A {
1376   int a;
1377 };
1378
1379 struct B {
1380   virtual void f();
1381 };
1382
1383 struct C : A, virtual B {
1384   virtual void f();
1385 };
1386
1387 // CHECK-37:      Vtable for 'Test31::D' (11 entries).
1388 // CHECK-37-NEXT:    0 | vbase_offset (0)
1389 // CHECK-37-NEXT:    1 | vbase_offset (8)
1390 // CHECK-37-NEXT:    2 | vcall_offset (0)
1391 // CHECK-37-NEXT:    3 | offset_to_top (0)
1392 // CHECK-37-NEXT:    4 | Test31::D RTTI
1393 // CHECK-37-NEXT:        -- (Test31::B, 0) vtable address --
1394 // CHECK-37-NEXT:        -- (Test31::D, 0) vtable address --
1395 // CHECK-37-NEXT:    5 | void Test31::D::f()
1396 // CHECK-37-NEXT:    6 | vbase_offset (-8)
1397 // CHECK-37-NEXT:    7 | vcall_offset (-8)
1398 // CHECK-37-NEXT:    8 | offset_to_top (-8)
1399 // CHECK-37-NEXT:    9 | Test31::D RTTI
1400 // CHECK-37-NEXT:        -- (Test31::C, 8) vtable address --
1401 // CHECK-37-NEXT:   10 | void Test31::D::f()
1402 // CHECK-37-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
1403 struct D : virtual C {
1404   virtual void f();
1405 };
1406 void D::f() { }
1407
1408 }
1409
1410 namespace Test32 {
1411
1412 // Check that we correctly lay out the virtual bases of 'Test32::D'.
1413
1414 struct A {
1415   virtual void f();
1416 };
1417
1418 struct B : virtual A { };
1419 struct C : A, virtual B { };
1420 struct D : virtual B { };
1421
1422 // CHECK-38:      Virtual base offset offsets for 'Test32::E' (3 entries).
1423 // CHECK-38-NEXT:    Test32::A | -32
1424 // CHECK-38-NEXT:    Test32::B | -24
1425 // CHECK-38-NEXT:    Test32::D | -40
1426 struct E : C, virtual D {
1427   virtual void f();
1428 };
1429 void E::f() { }
1430
1431 }
1432
1433 namespace Test33 {
1434
1435 // Test that we don't emit too many vcall offsets in 'Test32::F'.
1436
1437 struct A {
1438   virtual void a();
1439 };
1440
1441 struct B {
1442   virtual void b();
1443 };
1444
1445 struct C : virtual A, virtual B {
1446   virtual void c();
1447 };
1448
1449 struct D : virtual C { };
1450
1451 struct E : A, D {
1452   virtual void e();
1453 };
1454
1455 // CHECK-39:      Vtable for 'Test33::F' (30 entries).
1456 // CHECK-39-NEXT:    0 | vbase_offset (24)
1457 // CHECK-39-NEXT:    1 | vbase_offset (16)
1458 // CHECK-39-NEXT:    2 | vbase_offset (16)
1459 // CHECK-39-NEXT:    3 | vbase_offset (8)
1460 // CHECK-39-NEXT:    4 | offset_to_top (0)
1461 // CHECK-39-NEXT:    5 | Test33::F RTTI
1462 // CHECK-39-NEXT:        -- (Test33::A, 0) vtable address --
1463 // CHECK-39-NEXT:        -- (Test33::F, 0) vtable address --
1464 // CHECK-39-NEXT:    6 | void Test33::A::a()
1465 // CHECK-39-NEXT:    7 | void Test33::F::f()
1466 // CHECK-39-NEXT:    8 | vcall_offset (0)
1467 // CHECK-39-NEXT:    9 | vcall_offset (0)
1468 // CHECK-39-NEXT:   10 | vbase_offset (16)
1469 // CHECK-39-NEXT:   11 | vbase_offset (8)
1470 // CHECK-39-NEXT:   12 | vbase_offset (8)
1471 // CHECK-39-NEXT:   13 | offset_to_top (-8)
1472 // CHECK-39-NEXT:   14 | Test33::F RTTI
1473 // CHECK-39-NEXT:        -- (Test33::A, 8) vtable address --
1474 // CHECK-39-NEXT:        -- (Test33::E, 8) vtable address --
1475 // CHECK-39-NEXT:   15 | void Test33::A::a()
1476 // CHECK-39-NEXT:   16 | void Test33::E::e()
1477 // CHECK-39-NEXT:   17 | vbase_offset (0)
1478 // CHECK-39-NEXT:   18 | vcall_offset (0)
1479 // CHECK-39-NEXT:   19 | vbase_offset (8)
1480 // CHECK-39-NEXT:   20 | vbase_offset (0)
1481 // CHECK-39-NEXT:   21 | vcall_offset (0)
1482 // CHECK-39-NEXT:   22 | offset_to_top (-16)
1483 // CHECK-39-NEXT:   23 | Test33::F RTTI
1484 // CHECK-39-NEXT:        -- (Test33::A, 16) vtable address --
1485 // CHECK-39-NEXT:        -- (Test33::C, 16) vtable address --
1486 // CHECK-39-NEXT:        -- (Test33::D, 16) vtable address --
1487 // CHECK-39-NEXT:   24 | void Test33::A::a()
1488 // CHECK-39-NEXT:   25 | void Test33::C::c()
1489 // CHECK-39-NEXT:   26 | vcall_offset (0)
1490 // CHECK-39-NEXT:   27 | offset_to_top (-24)
1491 // CHECK-39-NEXT:   28 | Test33::F RTTI
1492 // CHECK-39-NEXT:        -- (Test33::B, 24) vtable address --
1493 // CHECK-39-NEXT:   29 | void Test33::B::b()
1494 struct F : virtual E, A {
1495   virtual void f();
1496 };
1497 void F::f() { }
1498
1499 }
1500
1501 namespace Test34 {
1502
1503 // Test that we lay out the construction vtable for 'Test34::E' in 'Test34::F' correctly.
1504
1505 struct A {
1506   virtual void a();
1507 };
1508 struct B : virtual A { };
1509
1510 struct C : B, A {
1511   virtual void c();
1512 };
1513
1514 struct D : A, C { };
1515
1516 struct E : virtual D {
1517   virtual void e();
1518 };
1519
1520 // CHECK-40:      Construction vtable for ('Test34::E', 0) in 'Test34::F' (22 entries).
1521 // CHECK-40-NEXT:    0 | vbase_offset (0)
1522 // CHECK-40-NEXT:    1 | vbase_offset (8)
1523 // CHECK-40-NEXT:    2 | vcall_offset (0)
1524 // CHECK-40-NEXT:    3 | offset_to_top (0)
1525 // CHECK-40-NEXT:    4 | Test34::E RTTI
1526 // CHECK-40-NEXT:        -- (Test34::A, 0) vtable address --
1527 // CHECK-40-NEXT:        -- (Test34::E, 0) vtable address --
1528 // CHECK-40-NEXT:    5 | void Test34::A::a()
1529 // CHECK-40-NEXT:    6 | void Test34::E::e()
1530 // CHECK-40-NEXT:    7 | vcall_offset (8)
1531 // CHECK-40-NEXT:    8 | vcall_offset (0)
1532 // CHECK-40-NEXT:    9 | vbase_offset (-8)
1533 // CHECK-40-NEXT:   10 | offset_to_top (-8)
1534 // CHECK-40-NEXT:   11 | Test34::E RTTI
1535 // CHECK-40-NEXT:        -- (Test34::A, 8) vtable address --
1536 // CHECK-40-NEXT:        -- (Test34::D, 8) vtable address --
1537 // CHECK-40-NEXT:   12 | void Test34::A::a()
1538 // CHECK-40-NEXT:   13 | vbase_offset (-16)
1539 // CHECK-40-NEXT:   14 | vcall_offset (-16)
1540 // CHECK-40-NEXT:   15 | offset_to_top (-16)
1541 // CHECK-40-NEXT:   16 | Test34::E RTTI
1542 // CHECK-40-NEXT:        -- (Test34::B, 16) vtable address --
1543 // CHECK-40-NEXT:        -- (Test34::C, 16) vtable address --
1544 // CHECK-40-NEXT:   17 | [unused] void Test34::A::a()
1545 // CHECK-40-NEXT:   18 | void Test34::C::c()
1546 // CHECK-40-NEXT:   19 | offset_to_top (-24)
1547 // CHECK-40-NEXT:   20 | Test34::E RTTI
1548 // CHECK-40-NEXT:        -- (Test34::A, 24) vtable address --
1549 // CHECK-40-NEXT:   21 | void Test34::A::a()
1550 struct F : E {
1551   virtual void f();
1552 };
1553 void F::f() { }
1554
1555 }
1556
1557 namespace Test35 {
1558
1559 // Test that we lay out the virtual bases of 'Test35::H' in the correct order.
1560
1561 struct A {
1562  virtual void a();
1563
1564  int i;
1565 };
1566
1567 struct B : virtual A {
1568  virtual void b();
1569 };
1570
1571 struct C {
1572  virtual void c();
1573 };
1574
1575 struct D : C, virtual B {
1576  virtual void d();
1577 };
1578
1579 struct E : D {
1580  virtual void e();
1581
1582  bool b;
1583 };
1584
1585 struct F : virtual D { };
1586 struct G : virtual E { };
1587
1588 // CHECK-41:      Vtable for 'Test35::H' (32 entries).
1589 // CHECK-41-NEXT:    0 | vbase_offset (32)
1590 // CHECK-41-NEXT:    1 | vbase_offset (0)
1591 // CHECK-41-NEXT:    2 | vcall_offset (0)
1592 // CHECK-41-NEXT:    3 | vcall_offset (0)
1593 // CHECK-41-NEXT:    4 | vbase_offset (16)
1594 // CHECK-41-NEXT:    5 | vbase_offset (8)
1595 // CHECK-41-NEXT:    6 | offset_to_top (0)
1596 // CHECK-41-NEXT:    7 | Test35::H RTTI
1597 // CHECK-41-NEXT:        -- (Test35::C, 0) vtable address --
1598 // CHECK-41-NEXT:        -- (Test35::D, 0) vtable address --
1599 // CHECK-41-NEXT:        -- (Test35::F, 0) vtable address --
1600 // CHECK-41-NEXT:        -- (Test35::H, 0) vtable address --
1601 // CHECK-41-NEXT:    8 | void Test35::C::c()
1602 // CHECK-41-NEXT:    9 | void Test35::D::d()
1603 // CHECK-41-NEXT:   10 | void Test35::H::h()
1604 // CHECK-41-NEXT:   11 | vbase_offset (0)
1605 // CHECK-41-NEXT:   12 | vbase_offset (24)
1606 // CHECK-41-NEXT:   13 | vcall_offset (0)
1607 // CHECK-41-NEXT:   14 | vbase_offset (8)
1608 // CHECK-41-NEXT:   15 | offset_to_top (-8)
1609 // CHECK-41-NEXT:   16 | Test35::H RTTI
1610 // CHECK-41-NEXT:        -- (Test35::B, 8) vtable address --
1611 // CHECK-41-NEXT:        -- (Test35::G, 8) vtable address --
1612 // CHECK-41-NEXT:   17 | void Test35::B::b()
1613 // CHECK-41-NEXT:   18 | vcall_offset (0)
1614 // CHECK-41-NEXT:   19 | offset_to_top (-16)
1615 // CHECK-41-NEXT:   20 | Test35::H RTTI
1616 // CHECK-41-NEXT:        -- (Test35::A, 16) vtable address --
1617 // CHECK-41-NEXT:   21 | void Test35::A::a()
1618 // CHECK-41-NEXT:   22 | vcall_offset (0)
1619 // CHECK-41-NEXT:   23 | vcall_offset (0)
1620 // CHECK-41-NEXT:   24 | vcall_offset (0)
1621 // CHECK-41-NEXT:   25 | vbase_offset (-16)
1622 // CHECK-41-NEXT:   26 | vbase_offset (-24)
1623 // CHECK-41-NEXT:   27 | offset_to_top (-32)
1624 // CHECK-41-NEXT:   28 | Test35::H RTTI
1625 // CHECK-41-NEXT:        -- (Test35::C, 32) vtable address --
1626 // CHECK-41-NEXT:        -- (Test35::D, 32) vtable address --
1627 // CHECK-41-NEXT:        -- (Test35::E, 32) vtable address --
1628 // CHECK-41-NEXT:   29 | void Test35::C::c()
1629 // CHECK-41-NEXT:   30 | void Test35::D::d()
1630 // CHECK-41-NEXT:   31 | void Test35::E::e()
1631
1632 // CHECK-41:      Virtual base offset offsets for 'Test35::H' (4 entries).
1633 // CHECK-41-NEXT:    Test35::A | -32
1634 // CHECK-41-NEXT:    Test35::B | -24
1635 // CHECK-41-NEXT:    Test35::D | -56
1636 // CHECK-41-NEXT:    Test35::E | -64
1637 struct H : F, G {
1638  virtual void h();
1639 };
1640 void H::h() { }
1641
1642 }
1643
1644 namespace Test36 {
1645
1646 // Test that we don't mark B::f as unused in the vtable for D.
1647
1648 struct A {
1649  virtual void f();
1650 };
1651
1652 struct B : virtual A { };
1653
1654 struct C : virtual A {
1655  virtual void f();
1656 };
1657
1658 // CHECK-42:      Vtable for 'Test36::D' (12 entries).
1659 // CHECK-42-NEXT:    0 | vbase_offset (8)
1660 // CHECK-42-NEXT:    1 | vbase_offset (8)
1661 // CHECK-42-NEXT:    2 | vcall_offset (0)
1662 // CHECK-42-NEXT:    3 | offset_to_top (0)
1663 // CHECK-42-NEXT:    4 | Test36::D RTTI
1664 // CHECK-42-NEXT:        -- (Test36::C, 0) vtable address --
1665 // CHECK-42-NEXT:        -- (Test36::D, 0) vtable address --
1666 // CHECK-42-NEXT:    5 | void Test36::C::f()
1667 // CHECK-42-NEXT:    6 | void Test36::D::g()
1668 // CHECK-42-NEXT:    7 | vbase_offset (0)
1669 // CHECK-42-NEXT:    8 | vcall_offset (-8)
1670 // CHECK-42-NEXT:    9 | offset_to_top (-8)
1671 // CHECK-42-NEXT:   10 | Test36::D RTTI
1672 // CHECK-42-NEXT:        -- (Test36::A, 8) vtable address --
1673 // CHECK-42-NEXT:        -- (Test36::B, 8) vtable address --
1674 // CHECK-42-NEXT:   11 | void Test36::C::f()
1675 // CHECK-42-NEXT:        [this adjustment: 0 non-virtual, -24 vcall offset offset]
1676 struct D : virtual B, C {
1677  virtual void g();
1678 };
1679 void D::g() { }
1680
1681 }