1 // RUN: %clang_cc1 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -std=c++98 -emit-llvm -o %t
2 // RUN: %clang_cc1 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -std=c++98 -O2 -disable-llvm-passes -emit-llvm -o %t.opt
3 // RUN: %clang_cc1 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -std=c++98 -O2 -disable-llvm-passes -emit-llvm -o %t.vtable -fforce-emit-vtables -fstrict-vtable-pointers -mconstructor-aliases
4 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST1 %s < %t
5 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST2 %s < %t
6 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST5 %s < %t
7 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST8 %s < %t.opt
8 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST9 %s < %t.opt
9 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST10 %s < %t.opt
10 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST11 %s < %t.opt
11 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST12 %s < %t.opt
12 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST13 %s < %t.opt
13 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST14 %s < %t.opt
14 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST15 %s < %t.opt
15 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST16 %s < %t.opt
16 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-TEST17 %s < %t.opt
17 // RUN: FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-FORCE-EMIT %s < %t.vtable
18
19
20 #include <typeinfo>
21
22 // CHECK-TEST1: @_ZTVN5Test11AE = external unnamed_addr constant
23 // CHECK-FORCE-EMIT-DAG: @_ZTVN5Test11AE = available_externally unnamed_addr constant
24 namespace Test1 {
25
26 struct A {
27 A();
28 virtual void f();
~ATest1::A29 virtual ~A() { }
30 };
31
A()32 A::A() { }
33
f(A * a)34 void f(A* a) {
35 a->f();
36 };
37
38 // CHECK-LABEL: define{{.*}} void @_ZN5Test11gEv
39 // CHECK: call void @_ZN5Test11A1fEv
g()40 void g() {
41 A a;
42 f(&a);
43 }
44
45 }
46
47 // Test2::A's key function (f) is defined in this translation unit, but when
48 // we're doing codegen for the typeid(A) call, we don't know that yet.
49 // This tests mainly that the typeinfo and typename constants have their linkage
50 // updated correctly.
51
52 // CHECK-TEST2: @_ZTSN5Test21AE ={{.*}} constant
53 // CHECK-TEST2: @_ZTIN5Test21AE ={{.*}} constant
54 // CHECK-TEST2: @_ZTVN5Test21AE ={{.*}} unnamed_addr constant
55 namespace Test2 {
56 struct A {
57 virtual void f();
58 };
59
g()60 const std::type_info &g() {
61 return typeid(A);
62 };
63
f()64 void A::f() { }
65 }
66
67 // Test that we don't assert on this test.
68 namespace Test3 {
69
70 struct A {
71 virtual void f();
~ATest3::A72 virtual ~A() { }
73 };
74
75 struct B : A {
76 B();
77 virtual void f();
78 };
79
B()80 B::B() { }
81
g(A * a)82 void g(A* a) {
83 a->f();
84 };
85
86 }
87
88 // PR9114, test that we don't try to instantiate RefPtr<Node>.
89 namespace Test4 {
90
91 template <class T> struct RefPtr {
92 T* p;
~RefPtrTest4::RefPtr93 ~RefPtr() {
94 p->deref();
95 }
96 };
97
98 struct A {
99 virtual ~A();
100 };
101
102 struct Node;
103
104 struct B : A {
105 virtual void deref();
106 RefPtr<Node> m;
107 };
108
f()109 void f() {
110 RefPtr<B> b;
111 }
112
113 }
114
115 // PR9130, test that we emit a definition of A::f.
116 // CHECK-TEST5-LABEL: define linkonce_odr void @_ZN5Test51A1fEv
117 namespace Test5 {
118
119 struct A {
fTest5::A120 virtual void f() { }
121 };
122
123 struct B : A {
124 virtual ~B();
125 };
126
~B()127 B::~B() { }
128
129 }
130
131 // Check that we don't assert on this test.
132 namespace Test6 {
133
134 struct A {
135 virtual ~A();
136 int a;
137 };
138
139 struct B {
140 virtual ~B();
141 int b;
142 };
143
144 struct C : A, B {
145 C();
146 };
147
148 struct D : C {
149 virtual void f();
150 D();
151 };
152
D()153 D::D() { }
154
155 }
156
157 namespace Test7 {
158
159 struct c1 {};
160 struct c10 : c1{
161 virtual void foo ();
162 };
163 struct c11 : c10, c1{
164 virtual void f6 ();
165 };
166 struct c28 : virtual c11{
167 void f6 ();
168 };
169 }
170
171 namespace Test8 {
172 // CHECK-TEST8: @_ZTVN5Test81YE = available_externally unnamed_addr constant
173 // vtable for X is not generated because there are no stores here
174 struct X {
175 X();
176 virtual void foo();
177 };
178 struct Y : X {
179 void foo();
180 };
181
g(X * p)182 void g(X* p) { p->foo(); }
f()183 void f() {
184 Y y;
185 g(&y);
186 X x;
187 g(&x);
188 }
189
190 } // Test8
191
192 namespace Test9 {
193 // All virtual functions are outline, so we can assume that it will
194 // be generated in translation unit where foo is defined.
195 // CHECK-TEST9-DAG: @_ZTVN5Test91AE = available_externally unnamed_addr constant
196 // CHECK-TEST9-DAG: @_ZTVN5Test91BE = available_externally unnamed_addr constant
197 struct A {
198 virtual void foo();
199 virtual void bar();
200 };
bar()201 void A::bar() {}
202
203 struct B : A {
204 void foo();
205 };
206
g()207 void g() {
208 A a;
209 a.foo();
210 B b;
211 b.foo();
212 }
213
214 } // Test9
215
216 namespace Test10 {
217
218 // because A's key function is defined here, vtable is generated in this TU
219 // CHECK-TEST10-DAG: @_ZTVN6Test101AE ={{.*}} unnamed_addr constant
220 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test101AE ={{.*}} unnamed_addr constant
221 struct A {
222 virtual void foo();
223 virtual void bar();
224 };
foo()225 void A::foo() {}
226
227 // Because key function is inline we will generate vtable as linkonce_odr.
228 // CHECK-TEST10-DAG: @_ZTVN6Test101DE = linkonce_odr unnamed_addr constant
229 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test101DE = linkonce_odr unnamed_addr constant
230 struct D : A {
231 void bar();
232 };
bar()233 inline void D::bar() {}
234
235 // Because B has outline all virtual functions, we can refer to them.
236 // CHECK-TEST10-DAG: @_ZTVN6Test101BE = available_externally unnamed_addr constant
237 struct B : A {
238 void foo();
239 void bar();
240 };
241
242 // C's key function (car) is outline, but C has inline virtual function so we
243 // can't guarantee that we will be able to refer to bar from name
244 // so (at the moment) we can't emit vtable available_externally.
245 // CHECK-TEST10-DAG: @_ZTVN6Test101CE = external unnamed_addr constant
246 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test101CE = available_externally unnamed_addr constant
247 struct C : A {
barTest10::C248 void bar() {} // defined in body - not key function
249 virtual inline void gar(); // inline in body - not key function
250 virtual void car();
251 };
252
253 // no key function, vtable will be generated everywhere it will be used
254 // CHECK-TEST10-DAG: @_ZTVN6Test101EE = linkonce_odr unnamed_addr constant
255 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test101EE = linkonce_odr unnamed_addr constant
256
257 struct E : A {};
258
g(A & a)259 void g(A& a) {
260 a.foo();
261 a.bar();
262 }
263
f()264 void f() {
265 A a;
266 g(a);
267 B b;
268 g(b);
269 C c;
270 g(c);
271 D d;
272 g(d);
273 E e;
274 g(e);
275 }
276
277 } // Test10
278
279 namespace Test11 {
280 struct D;
281 // Can emit C's vtable available_externally.
282 // CHECK-TEST11: @_ZTVN6Test111CE = available_externally unnamed_addr constant
283 struct C {
284 virtual D& operator=(const D&);
285 };
286
287 // Can emit D's vtable available_externally.
288 // CHECK-TEST11: @_ZTVN6Test111DE = available_externally unnamed_addr constant
289 struct D : C {
290 virtual void key();
291 };
292 D f();
293
g(D & a)294 void g(D& a) {
295 C c;
296 c = a;
297 a.key();
298 a.key();
299 }
g()300 void g() {
301 D d;
302 d = f();
303 g(d);
304 }
305 } // Test 11
306
307 namespace Test12 {
308
309 // CHECK-TEST12: @_ZTVN6Test121AE = external unnamed_addr constant
310 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test121AE = available_externally unnamed_addr constant
311 struct A {
312 virtual void foo();
~ATest12::A313 virtual ~A() {}
314 };
315 // CHECK-TEST12: @_ZTVN6Test121BE = external unnamed_addr constant
316 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test121BE = available_externally unnamed_addr constant
317 struct B : A {
318 void foo();
319 };
320
g()321 void g() {
322 A a;
323 a.foo();
324 B b;
325 b.foo();
326 }
327 }
328
329 namespace Test13 {
330
331 // CHECK-TEST13-DAG: @_ZTVN6Test131AE = available_externally unnamed_addr constant
332 // CHECK-TEST13-DAG: @_ZTVN6Test131BE = external unnamed_addr constant
333 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test131AE = available_externally unnamed_addr constant
334 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test131BE = available_externally unnamed_addr constant
335
336 struct A {
337 virtual ~A();
338 };
339 struct B : A {
340 virtual void f();
341 void operator delete(void *);
~BTest13::B342 ~B() {}
343 };
344
g()345 void g() {
346 A *b = new B;
347 }
348 }
349
350 namespace Test14 {
351
352 // CHECK-TEST14: @_ZTVN6Test141AE = available_externally unnamed_addr constant
353 struct A {
354 virtual void f();
355 void operator delete(void *);
356 ~A();
357 };
358
g()359 void g() {
360 A *b = new A;
361 delete b;
362 }
363 }
364
365 namespace Test15 {
366 // In this test D's vtable has two slots for function f(), but uses only one,
367 // so the second slot is set to null.
368 // CHECK-TEST15: @_ZTVN6Test151DE = available_externally unnamed_addr constant
fTest15::A369 struct A { virtual void f() {} };
370 struct B : virtual A {};
371 struct C : virtual A {};
372 struct D : B, C {
373 virtual void g();
374 void f();
375 };
376
test()377 void test() {
378 D * d = new D;
379 d->f();
380 }
381 }
382
383 namespace Test16 {
384 // S has virtual method that is hidden, because of it we can't
385 // generate available_externally vtable for it.
386 // CHECK-TEST16-DAG: @_ZTVN6Test161SE = external unnamed_addr constant
387 // CHECK-TEST16-DAG: @_ZTVN6Test162S2E = available_externally
388 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test161SE = external unnamed_addr constant
389 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test162S2E = available_externally
390
391 struct S {
392 __attribute__((visibility("hidden"))) virtual void doStuff();
393 };
394
395 struct S2 {
396 virtual void doStuff();
397 __attribute__((visibility("hidden"))) void unused();
398
399 };
400
test()401 void test() {
402 S *s = new S;
403 s->doStuff();
404
405 S2 *s2 = new S2;
406 s2->doStuff();
407 }
408 }
409
410 namespace Test17 {
411 // This test checks if we emit vtables opportunistically.
412 // CHECK-TEST17-DAG: @_ZTVN6Test171AE = available_externally
413 // CHECK-TEST17-DAG: @_ZTVN6Test171BE = external
414 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test171AE = available_externally
415 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test171BE = available_externally
416 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test171BD2Ev(
417 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test171BD0Ev(
418
419 struct A {
420 virtual void key();
barTest17::A421 virtual void bar() {}
422 };
423
424 // We won't gonna use deleting destructor for this type, which will disallow
425 // emitting vtable as available_externally
426 struct B {
427 virtual void key();
~BTest17::B428 virtual ~B() {}
429 };
430
testcaseA()431 void testcaseA() {
432 A a;
433 a.bar(); // this forces to emit definition of bar
434 }
435
testcaseB()436 void testcaseB() {
437 B b; // This only forces emitting of complete object destructor
438 }
439
440 } // namespace Test17
441
442 namespace Test18 {
443 // Here vtable will be only emitted because it is referenced by assume-load
444 // after the Derived construction.
445 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test187DerivedE = linkonce_odr unnamed_addr constant {{.*}} @_ZTIN6Test187DerivedE {{.*}} @_ZN6Test184Base3funEv {{.*}} @_ZN6Test184BaseD2Ev {{.*}} @_ZN6Test187DerivedD0Ev
446 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test187DerivedD0Ev
447 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test184BaseD2Ev
448 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN6Test184Base3funEv
449 // CHECK-FORCE-EMIT-DAG: @_ZTIN6Test187DerivedE = linkonce_odr constant
450
451 struct Base {
funTest18::Base452 virtual int fun() { return 42; }
~BaseTest18::Base453 virtual ~Base() { }
454 };
455
456 struct Derived : Base {
457 Derived();
458 };
459
foo()460 int foo() {
461 Derived *der = new Derived();
462 return der->fun();
463 }
464 }
465
466 namespace TestTemplates {
467
468 // CHECK-FORCE-EMIT-DAG: @_ZTVN13TestTemplates8TemplateIiEE = linkonce_odr unnamed_addr constant {{.*}} @_ZTIN13TestTemplates8TemplateIiEE {{.*}} @_ZN13TestTemplates8TemplateIiE3fooEi {{.*}}@_ZN13TestTemplates8TemplateIiE22thisShouldBeEmittedTooEi {{.*}}@_ZN13TestTemplates8TemplateIiED1Ev {{.*}}@_ZN13TestTemplates8TemplateIiED0Ev
469 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates8TemplateIiE22thisShouldBeEmittedTooEi
470
471 template<class T>
472 struct Template {
473 Template();
474 virtual T foo(T val);
475 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates8TemplateIiE22thisShouldBeEmittedTooEi
thisShouldBeEmittedTooTestTemplates::Template476 virtual T thisShouldBeEmittedToo(T val) { return val; }
477 virtual ~Template();
478 };
479
480
481 struct NonTemplate {
482 typedef int T;
483 NonTemplate();
484 virtual T foo(T val);
485 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates11NonTemplate22thisShouldBeEmittedTooEi
thisShouldBeEmittedTooTestTemplates::NonTemplate486 virtual T thisShouldBeEmittedToo(T val) { return val; }
487 virtual ~NonTemplate();
488 };
489
490 // CHECK-FORCE-EMIT-DAG: @_ZTVN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiEE = linkonce_odr {{.*}} @_ZTIN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiEE {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiE3fooEi {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiE22thisShouldBeEmittedTooEi {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiED1Ev {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiED0Ev
491
492 struct OuterNonTemplate {
493 template<class T>
494 struct NestedTemplateInNonTemplate {
495 NestedTemplateInNonTemplate();
496 virtual T foo(T val);
497 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiE22thisShouldBeEmittedTooEi
thisShouldBeEmittedTooTestTemplates::OuterNonTemplate::NestedTemplateInNonTemplate498 virtual T thisShouldBeEmittedToo(T val) { return val; }
499 virtual ~NestedTemplateInNonTemplate();
500 };
501
502 struct NestedNonTemplateInNonTemplate {
503 typedef int T;
504 NestedNonTemplateInNonTemplate();
505 virtual T foo(T val);
506 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates16OuterNonTemplate30NestedNonTemplateInNonTemplate22thisShouldBeEmittedTooEi
thisShouldBeEmittedTooTestTemplates::OuterNonTemplate::NestedNonTemplateInNonTemplate507 virtual T thisShouldBeEmittedToo(T val) { return val; }
508 virtual ~NestedNonTemplateInNonTemplate();
509 };
510 };
511
512 template<class>
513 struct OuterTemplate {
514 template<class T>
515 struct NestedTemplateInTemplate {
516 NestedTemplateInTemplate();
517 virtual T foo(T val);
518 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates13OuterTemplateIlE24NestedTemplateInTemplateIiE22thisShouldBeEmittedTooEi
thisShouldBeEmittedTooTestTemplates::OuterTemplate::NestedTemplateInTemplate519 virtual T thisShouldBeEmittedToo(T val) { return val; }
520 virtual ~NestedTemplateInTemplate();
521 };
522
523 struct NestedNonTemplateInTemplate {
524 typedef int T;
525 NestedNonTemplateInTemplate();
526 virtual T foo(T val);
527 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates13OuterTemplateIlE27NestedNonTemplateInTemplate22thisShouldBeEmittedTooEi
thisShouldBeEmittedTooTestTemplates::OuterTemplate::NestedNonTemplateInTemplate528 virtual T thisShouldBeEmittedToo(T val) { return val; }
529 virtual ~NestedNonTemplateInTemplate();
530 };
531 };
532
533 template<class T>
use()534 int use() {
535 T *ptr = new T();
536 return ptr->foo(42);
537 }
538
test()539 void test() {
540 use<Template<int> >();
541 use<OuterTemplate<long>::NestedTemplateInTemplate<int> >();
542 use<OuterNonTemplate::NestedTemplateInNonTemplate<int> >();
543
544 use<NonTemplate>();
545 use<OuterTemplate<long>::NestedNonTemplateInTemplate>();
546 use<OuterNonTemplate::NestedNonTemplateInNonTemplate>();
547 }
548 }
549