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