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