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. 48 namespace 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 57 namespace 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() 63 struct A { 64 virtual void f(); 65 }; 66 void A::f() { } 67 68 } 69 70 namespace 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 &) 84 struct 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 }; 93 void 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] 105 struct B { 106 virtual void f(); 107 virtual void g() = 0; 108 virtual ~B() = 0; 109 }; 110 void B::f() { } 111 112 } 113 114 namespace 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() 125 struct A { 126 virtual void f(); 127 }; 128 void 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() 137 struct B : A { 138 virtual void f(); 139 virtual void g(); 140 }; 141 void 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() 151 struct C : A { 152 virtual void g(); 153 virtual void h(); 154 }; 155 void 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() 166 struct D : B { 167 virtual void f(); 168 virtual void g(); 169 virtual void h(); 170 }; 171 172 void D::f() { } 173 } 174 175 namespace Test4 { 176 177 // Test non-virtual result adjustments. 178 179 struct R1 { int r1; }; 180 struct R2 { int r2; }; 181 struct R3 : R1, R2 { int r3; }; 182 183 struct 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 196 struct B : A { 197 virtual R3 *f(); 198 }; 199 R3 *B::f() { return 0; } 200 201 // Test virtual result adjustments. 202 struct V1 { int v1; }; 203 struct V2 : virtual V1 { int v1; }; 204 205 struct 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() 217 struct D : C { 218 virtual V2 *f(); 219 }; 220 V2 *D::f() { return 0; }; 221 222 // Virtual result adjustments with an additional non-virtual adjustment. 223 struct 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 234 struct E : A { 235 virtual V3 *f(); 236 }; 237 V3 *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] 249 struct F : A { 250 virtual void g(); 251 virtual R3 *f() = 0; 252 }; 253 void F::g() { } 254 255 } 256 257 namespace Test5 { 258 259 // Simple secondary vtables without 'this' pointer adjustments. 260 struct A { 261 virtual void f(); 262 virtual void g(); 263 int a; 264 }; 265 266 struct B1 : A { 267 virtual void f(); 268 int b1; 269 }; 270 271 struct 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() 291 struct C : B1, B2 { 292 virtual void h(); 293 }; 294 void C::h() { } 295 } 296 297 namespace Test6 { 298 299 // Simple non-virtual 'this' pointer adjustments. 300 struct A1 { 301 virtual void f(); 302 int a; 303 }; 304 305 struct 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] 321 struct C : A1, A2 { 322 virtual void f(); 323 }; 324 void C::f() { } 325 326 } 327 328 namespace 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 333 struct A { 334 virtual void f(); 335 int a; 336 }; 337 338 struct B1 : A { }; 339 struct B2 : A { }; 340 341 struct 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] 362 struct D : C, B1, B2 { 363 virtual void f(); 364 }; 365 void D::f() { } 366 367 } 368 369 namespace 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 374 struct 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() 381 struct B : A { 382 virtual void f(); 383 }; 384 void B::f() { } 385 386 } 387 388 namespace Test9 { 389 390 // Simple test of vbase offsets. 391 392 struct A1 { int a1; }; 393 struct 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() 402 struct B : virtual A1, virtual A2 { 403 int b; 404 405 virtual void f(); 406 }; 407 408 409 void B::f() { } 410 411 } 412 413 namespace Test10 { 414 415 // Test for a bug where we would not emit secondary vtables for bases 416 // of a primary base. 417 struct A1 { virtual void a1(); }; 418 struct 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() 432 struct B : A1, A2 { 433 int b; 434 }; 435 436 struct C : B { 437 virtual void f(); 438 }; 439 void C::f() { } 440 441 } 442 443 namespace Test11 { 444 445 // Very simple test of vtables for virtual bases. 446 struct A1 { int a; }; 447 struct A2 { int b; }; 448 449 struct 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 463 struct C : virtual B { 464 virtual void f(); 465 }; 466 void C::f() { } 467 468 } 469 470 namespace 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() 500 struct A1 { 501 virtual void a1(); 502 int a; 503 }; 504 505 struct A2 { 506 virtual void a2(); 507 int a; 508 }; 509 510 struct A3 { 511 virtual void a3(); 512 int a; 513 }; 514 515 struct A : A1, A2, A3 { 516 virtual void a(); 517 int i; 518 }; 519 520 struct B : virtual A { 521 virtual void f(); 522 523 virtual void a(); 524 }; 525 void B::f() { } 526 527 } 528 529 namespace Test13 { 530 531 // Test that we don't try to emit a vtable for 'A' twice. 532 struct A { 533 virtual void f(); 534 }; 535 536 struct 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() 550 struct C : virtual B, virtual A { 551 virtual void f(); 552 }; 553 void C::f() { } 554 555 } 556 557 namespace Test14 { 558 559 // Verify that we handle A being a non-virtual base of B, which is a virtual base. 560 561 struct A { 562 virtual void f(); 563 }; 564 565 struct B : A { }; 566 567 struct 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() 579 struct D : C, virtual B { 580 virtual void f(); 581 }; 582 void D::f() { } 583 584 } 585 586 namespace Test15 { 587 588 // Test that we don't emit an extra vtable for B since it's a primary base of C. 589 struct A { virtual void a(); }; 590 struct B { virtual void b(); }; 591 592 struct 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() 610 struct D : A, virtual B, virtual C { 611 virtual void f(); 612 }; 613 void D::f() { } 614 615 } 616 617 namespace Test16 { 618 619 // Test that destructors share vcall offsets. 620 621 struct A { virtual ~A(); }; 622 struct B { virtual ~B(); }; 623 624 struct 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] 650 struct D : virtual C { 651 virtual void f(); 652 }; 653 void D::f() { } 654 655 } 656 657 namespace Test17 { 658 659 // Test that we don't mark E::f in the C-in-E vtable as unused. 660 struct A { virtual void f(); }; 661 struct B : virtual A { virtual void f(); }; 662 struct C : virtual A { virtual void f(); }; 663 struct 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] 685 class E : virtual D { 686 virtual void f(); 687 }; 688 void E::f() {} 689 690 } 691 692 namespace Test18 { 693 694 // Test that we compute the right 'this' adjustment offsets. 695 696 struct A { 697 virtual void f(); 698 virtual void g(); 699 }; 700 701 struct B : virtual A { 702 virtual void f(); 703 }; 704 705 struct 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() 800 struct D : virtual B, virtual C, virtual A 801 { 802 virtual void f(); 803 virtual void h(); 804 }; 805 void D::f() {} 806 807 } 808 809 namespace Test19 { 810 811 // Another 'this' adjustment test. 812 813 struct A { 814 int a; 815 816 virtual void f(); 817 }; 818 819 struct B : A { 820 int b; 821 822 virtual void g(); 823 }; 824 825 struct 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] 850 struct D : C, B, virtual A { 851 virtual void f(); 852 }; 853 void D::f() { } 854 855 } 856 857 namespace Test20 { 858 859 // pure virtual member functions should never have 'this' adjustments. 860 861 struct A { 862 virtual void f() = 0; 863 virtual void g(); 864 }; 865 866 struct 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() 882 struct C : A, B { 883 virtual void f() = 0; 884 virtual void h(); 885 }; 886 void C::h() { } 887 888 } 889 890 namespace Test21 { 891 892 // Test that we get vbase offsets right in secondary vtables. 893 struct A { 894 virtual void f(); 895 }; 896 897 struct B : virtual A { }; 898 class C : virtual B { }; 899 class D : virtual C { }; 900 901 class 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 933 class F : virtual D, virtual E { 934 virtual void f(); 935 }; 936 void F::f() { } 937 938 } 939 940 namespace Test22 { 941 942 // Very simple construction vtable test. 943 struct V1 { 944 int v1; 945 }; 946 947 struct 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 968 struct C : virtual V1, virtual V2 { 969 int c; 970 virtual void f(); 971 }; 972 void C::f() { } 973 974 } 975 976 namespace Test23 { 977 978 struct A { 979 int a; 980 }; 981 982 struct B : virtual A { 983 int b; 984 }; 985 986 struct 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 1019 struct D : virtual A, virtual B, C { 1020 int d; 1021 1022 void f(); 1023 }; 1024 void D::f() { } 1025 D d; 1026 } 1027 1028 namespace Test24 { 1029 1030 // Another construction vtable test. 1031 1032 struct A { 1033 virtual void f(); 1034 }; 1035 1036 struct B : virtual A { }; 1037 struct 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() 1076 struct D : B, C { 1077 virtual void f(); 1078 }; 1079 void D::f() { } 1080 1081 } 1082 1083 namespace Test25 { 1084 1085 // This mainly tests that we don't assert on this class hierarchy. 1086 1087 struct V { 1088 virtual void f(); 1089 }; 1090 1091 struct A : virtual V { }; 1092 struct 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() 1132 struct C : A, virtual V, B { 1133 virtual void g(); 1134 }; 1135 void C::g() { } 1136 1137 } 1138 1139 namespace 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 1144 struct A { 1145 virtual void a(); 1146 }; 1147 1148 struct B { 1149 virtual void c(); 1150 }; 1151 1152 struct 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() 1187 class D : virtual B, virtual C { 1188 virtual void d(); 1189 }; 1190 void D::d() { } 1191 1192 } 1193 1194 namespace 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 1199 struct A { 1200 virtual void a(); 1201 }; 1202 1203 struct B { 1204 virtual void b(); 1205 }; 1206 1207 struct C { 1208 virtual void c(); 1209 }; 1210 1211 struct 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() 1248 struct E : D { 1249 virtual void e(); 1250 }; 1251 void E::e() { } 1252 1253 } 1254 1255 namespace 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 1260 struct A { 1261 virtual void a(); 1262 }; 1263 1264 struct B { 1265 virtual void b(); 1266 }; 1267 1268 struct C : A, B { 1269 virtual void c(); 1270 }; 1271 1272 struct 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() 1314 struct E : D { 1315 virtual void e(); 1316 }; 1317 void E::e() { } 1318 1319 } 1320 1321 namespace Test29 { 1322 1323 // Test that the covariant return thunk for B::f will have a virtual 'this' adjustment, 1324 // matching gcc. 1325 1326 struct V1 { }; 1327 struct V2 : virtual V1 { }; 1328 1329 struct 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() 1344 struct B : virtual A { 1345 virtual V2 *f(); 1346 }; 1347 V2 *B::f() { return 0; } 1348 1349 } 1350 1351 namespace Test30 { 1352 1353 // Test that we don't assert when generating a vtable for F. 1354 struct A { }; 1355 1356 struct B : virtual A { 1357 int i; 1358 }; 1359 1360 struct C { 1361 virtual void f(); 1362 }; 1363 1364 struct D : virtual C, B { }; 1365 struct E : virtual D { }; 1366 1367 struct F : E { 1368 virtual void f(); 1369 }; 1370 void F::f() { } 1371 1372 } 1373 1374 namespace Test31 { 1375 1376 // Test that we don't add D::f twice to the primary vtable. 1377 struct A { 1378 int a; 1379 }; 1380 1381 struct B { 1382 virtual void f(); 1383 }; 1384 1385 struct 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] 1405 struct D : virtual C { 1406 virtual void f(); 1407 }; 1408 void D::f() { } 1409 1410 } 1411 1412 namespace Test32 { 1413 1414 // Check that we correctly lay out the virtual bases of 'Test32::D'. 1415 1416 struct A { 1417 virtual void f(); 1418 }; 1419 1420 struct B : virtual A { }; 1421 struct C : A, virtual B { }; 1422 struct 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 1428 struct E : C, virtual D { 1429 virtual void f(); 1430 }; 1431 void E::f() { } 1432 1433 } 1434 1435 namespace Test33 { 1436 1437 // Test that we don't emit too many vcall offsets in 'Test32::F'. 1438 1439 struct A { 1440 virtual void a(); 1441 }; 1442 1443 struct B { 1444 virtual void b(); 1445 }; 1446 1447 struct C : virtual A, virtual B { 1448 virtual void c(); 1449 }; 1450 1451 struct D : virtual C { }; 1452 1453 struct 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() 1496 struct F : virtual E, A { 1497 virtual void f(); 1498 }; 1499 void F::f() { } 1500 1501 } 1502 1503 namespace Test34 { 1504 1505 // Test that we lay out the construction vtable for 'Test34::E' in 'Test34::F' correctly. 1506 1507 struct A { 1508 virtual void a(); 1509 }; 1510 struct B : virtual A { }; 1511 1512 struct C : B, A { 1513 virtual void c(); 1514 }; 1515 1516 struct D : A, C { }; 1517 1518 struct 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() 1552 struct F : E { 1553 virtual void f(); 1554 }; 1555 void F::f() { } 1556 1557 } 1558 1559 namespace Test35 { 1560 1561 // Test that we lay out the virtual bases of 'Test35::H' in the correct order. 1562 1563 struct A { 1564 virtual void a(); 1565 1566 int i; 1567 }; 1568 1569 struct B : virtual A { 1570 virtual void b(); 1571 }; 1572 1573 struct C { 1574 virtual void c(); 1575 }; 1576 1577 struct D : C, virtual B { 1578 virtual void d(); 1579 }; 1580 1581 struct E : D { 1582 virtual void e(); 1583 1584 bool b; 1585 }; 1586 1587 struct F : virtual D { }; 1588 struct 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 1639 struct H : F, G { 1640 virtual void h(); 1641 }; 1642 void H::h() { } 1643 1644 } 1645 1646 namespace Test36 { 1647 1648 // Test that we don't mark B::f as unused in the vtable for D. 1649 1650 struct A { 1651 virtual void f(); 1652 }; 1653 1654 struct B : virtual A { }; 1655 1656 struct 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] 1678 struct D : virtual B, C { 1679 virtual void g(); 1680 }; 1681 void D::g() { } 1682 1683 } 1684 1685 namespace Test37 { 1686 1687 // Test that we give C::f the right vtable index. (PR9660). 1688 struct A { 1689 virtual A* f() = 0; 1690 }; 1691 1692 struct 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() 1698 struct C : B { 1699 virtual C* f(); 1700 }; 1701 1702 C* C::f() { return 0; } 1703 1704 } 1705 1706 // rdar://problem/10959710 1707 namespace 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