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