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