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