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