Clang Project

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