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