clang/test/CodeGenCXX/vtable-layout.cpp

   1 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm-only -fdump-vtable-layouts > %t
   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 | 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 | A &Test2::A::operator=(const 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 | 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 | A &Test2::A::operator=(const 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 | R3 *Test4::B::f()
 229 // CHECK-8-NEXT:      [return adjustment: 4 non-virtual]
 230 // CHECK-8-NEXT:  3 | R3 *Test4::B::f()
 231 //
 232 // CHECK-8:     VTable indices for 'Test4::B' (1 entries).
 233 // CHECK-8-NEXT:  1 | 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 | V2 *Test4::D::f()
 253 // CHECK-9-NEXT:       [return adjustment: 0 non-virtual, -24 vbase offset offset]
 254 // CHECK-9-NEXT:   3 | V2 *Test4::D::f()
 255 //
 256 // CHECK-9:     VTable indices for 'Test4::D' (1 entries).
 257 // CHECK-9-NEXT:   1 | 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 | V3 *Test4::E::f()
 272 // CHECK-10-NEXT:       [return adjustment: 4 non-virtual, -24 vbase offset offset]
 273 // CHECK-10-NEXT:   3 | V3 *Test4::E::f()
 274 //
 275 // CHECK-10:     VTable indices for 'Test4::E' (1 entries).
 276 // CHECK-10-NEXT:   1 | 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 | R3 *Test4::F::f() [pure]
 290 // CHECK-11-NEXT:   3 | void Test4::F::g()
 291 // CHECK-11-NEXT:   4 | 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 | 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 | 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 | V2 *Test29::B::f()
1465 //
1466 // CHECK-36:      VTable indices for 'Test29::B' (1 entries).
1467 // CHECK-36-NEXT:    1 | 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 | C *Test37::C::f()
1834 struct C : B {
1835   virtual C* f();
1836 };
1837
1838 C* C::f() { return 0; }
1839
1840 }
1841
1842 namespace Test38 {
1843   struct A {
1844     virtual void *foo();
1845     virtual const void *foo() const;
1846   };
1847
1848   // CHECK-44:      Vtable for 'Test38::B' (7 entries).
1849   // CHECK-44-NEXT:    0 | vbase_offset (0)
1850   // CHECK-44-NEXT:    1 | vcall_offset (0)
1851   // CHECK-44-NEXT:    2 | vcall_offset (0)
1852   // CHECK-44-NEXT:    3 | offset_to_top (0)
1853   // CHECK-44-NEXT:    4 | Test38::B RTTI
1854   // CHECK-44-NEXT:        -- (Test38::A, 0) vtable address --
1855   // CHECK-44-NEXT:        -- (Test38::B, 0) vtable address --
1856   // CHECK-44-NEXT:    5 | void *Test38::B::foo()
1857   // CHECK-44-NEXT:    6 | const void *Test38::B::foo() const
1858   //
1859   // CHECK-44:      VTable indices for 'Test38::B' (2 entries).
1860   // CHECK-44-NEXT:    0 | void *Test38::B::foo()
1861   // CHECK-44-NEXT:    1 | const void *Test38::B::foo() const
1862   class B : virtual public A {
1863     void *foo();
1864     const void *foo() const;
1865   };
1866
1867   void *B::foo() { return 0; }
1868 }
1869
1870 namespace Test39 {
1871   struct A {
1872     virtual void foo() = delete;
1873   };
1874
1875   // CHECK-45:      Vtable for 'Test39::B' (4 entries).
1876   // CHECK-45-NEXT:    0 | offset_to_top (0)
1877   // CHECK-45-NEXT:    1 | Test39::B RTTI
1878   // CHECK-45-NEXT:        -- (Test39::A, 0) vtable address --
1879   // CHECK-45-NEXT:        -- (Test39::B, 0) vtable address --
1880   // CHECK-45-NEXT:    2 | void Test39::A::foo() [deleted]
1881   // CHECK-45-NEXT:    3 | void Test39::B::foo2()
1882   //
1883   // CHECK-45:      VTable indices for 'Test39::B' (1 entries).
1884   // CHECK-45-NEXT:    1 | void Test39::B::foo2()
1885   struct B: A {
1886     virtual void foo2();
1887   };
1888
1889   void B::foo2() {
1890   }
1891 }
1892
1893 namespace Test40 {
1894   struct A {
1895     virtual void foo() = 0;
1896   };
1897
1898   struct B : public A {
1899     virtual void foo();
1900   };
1901
1902   struct C: public B {
1903     // CHECK-46: VTable indices for 'Test40::C' (8 entries).
1904     // CHECK-46-NEXT: 1 | int Test40::C::f(int)
1905     // CHECK-46-NEXT: 2 | int Test40::C::f()
1906     // CHECK-46-NEXT: 3 | int Test40::C::g(int)
1907     // CHECK-46-NEXT: 4 | int Test40::C::g()
1908     // CHECK-46-NEXT: 5 | int Test40::C::h(int)
1909     // CHECK-46-NEXT: 6 | int Test40::C::h()
1910     // CHECK-46-NEXT: 7 | int Test40::C::i(int)
1911     // CHECK-46-NEXT: 8 | int Test40::C::i()
1912     virtual int f(int);
1913     virtual int f();
1914     virtual int g(int);
1915     virtual int g();
1916     virtual int h(int);
1917     virtual int h();
1918     virtual int i(int);
1919     virtual int i();
1920   };
1921   // Force C's vtable to be generated.
1922   int C::f() { return 1; }
1923
1924   class D : C {};
1925
1926   D d;
1927 }