1 // RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -std=c++98 -emit-llvm -o %t 2 // RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -std=c++98 -O2 -disable-llvm-passes -emit-llvm -o %t.opt 3 // RUN: %clang_cc1 %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(); 29 virtual ~A() { } 30 }; 31 32 A::A() { } 33 34 void f(A* a) { 35 a->f(); 36 }; 37 38 // CHECK-LABEL: define{{.*}} void @_ZN5Test11gEv 39 // CHECK: call void @_ZN5Test11A1fEv 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: @_ZTIN5Test21AE ={{.*}} constant 53 // CHECK-TEST2: @_ZTSN5Test21AE ={{.*}} constant 54 // CHECK-TEST2: @_ZTVN5Test21AE ={{.*}} unnamed_addr constant 55 namespace Test2 { 56 struct A { 57 virtual void f(); 58 }; 59 60 const std::type_info &g() { 61 return typeid(A); 62 }; 63 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(); 72 virtual ~A() { } 73 }; 74 75 struct B : A { 76 B(); 77 virtual void f(); 78 }; 79 80 B::B() { } 81 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; 93 ~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 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 { 120 virtual void f() { } 121 }; 122 123 struct B : A { 124 virtual ~B(); 125 }; 126 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 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 182 void g(X* p) { p->foo(); } 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 }; 201 void A::bar() {} 202 203 struct B : A { 204 void foo(); 205 }; 206 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 }; 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 }; 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 { 248 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 // Inline definition outside body, so we can't emit vtable available_externally 254 // (see previous). 255 // CHECK-TEST10-DAG: @_ZTVN6Test101FE = external unnamed_addr constant 256 struct F : A { 257 void foo(); 258 virtual void cat(); // inline outside body 259 }; 260 inline void F::cat() {} 261 262 // no key function, vtable will be generated everywhere it will be used 263 // CHECK-TEST10-DAG: @_ZTVN6Test101EE = linkonce_odr unnamed_addr constant 264 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test101EE = linkonce_odr unnamed_addr constant 265 266 struct E : A {}; 267 268 void h(A& a) { 269 a.foo(); 270 a.bar(); 271 } 272 273 void g() { 274 A a; 275 h(a); 276 B b; 277 h(b); 278 C c; 279 h(c); 280 D d; 281 h(d); 282 E e; 283 h(e); 284 F f; 285 h(f); 286 } 287 288 } // Test10 289 290 namespace Test11 { 291 struct D; 292 // Can emit C's vtable available_externally. 293 // CHECK-TEST11: @_ZTVN6Test111CE = available_externally unnamed_addr constant 294 struct C { 295 virtual D& operator=(const D&); 296 }; 297 298 // Can emit D's vtable available_externally. 299 // CHECK-TEST11: @_ZTVN6Test111DE = available_externally unnamed_addr constant 300 struct D : C { 301 virtual void key(); 302 }; 303 D f(); 304 305 void g(D& a) { 306 C c; 307 c = a; 308 a.key(); 309 a.key(); 310 } 311 void g() { 312 D d; 313 d = f(); 314 g(d); 315 } 316 } // Test 11 317 318 namespace Test12 { 319 320 // CHECK-TEST12: @_ZTVN6Test121AE = external unnamed_addr constant 321 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test121AE = available_externally unnamed_addr constant 322 struct A { 323 virtual void foo(); 324 virtual ~A() {} 325 }; 326 // CHECK-TEST12: @_ZTVN6Test121BE = external unnamed_addr constant 327 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test121BE = available_externally unnamed_addr constant 328 struct B : A { 329 void foo(); 330 }; 331 332 void g() { 333 A a; 334 a.foo(); 335 B b; 336 b.foo(); 337 } 338 } 339 340 namespace Test13 { 341 342 // CHECK-TEST13-DAG: @_ZTVN6Test131AE = available_externally unnamed_addr constant 343 // CHECK-TEST13-DAG: @_ZTVN6Test131BE = external unnamed_addr constant 344 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test131AE = available_externally unnamed_addr constant 345 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test131BE = available_externally unnamed_addr constant 346 347 struct A { 348 virtual ~A(); 349 }; 350 struct B : A { 351 virtual void f(); 352 void operator delete(void *); 353 ~B() {} 354 }; 355 356 void g() { 357 A *b = new B; 358 } 359 } 360 361 namespace Test14 { 362 363 // CHECK-TEST14: @_ZTVN6Test141AE = available_externally unnamed_addr constant 364 struct A { 365 virtual void f(); 366 void operator delete(void *); 367 ~A(); 368 }; 369 370 void g() { 371 A *b = new A; 372 delete b; 373 } 374 } 375 376 namespace Test15 { 377 // In this test D's vtable has two slots for function f(), but uses only one, 378 // so the second slot is set to null. 379 // CHECK-TEST15: @_ZTVN6Test151DE = available_externally unnamed_addr constant 380 struct A { virtual void f() {} }; 381 struct B : virtual A {}; 382 struct C : virtual A {}; 383 struct D : B, C { 384 virtual void g(); 385 void f(); 386 }; 387 388 void test() { 389 D * d = new D; 390 d->f(); 391 } 392 } 393 394 namespace Test16 { 395 // S has virtual method that is hidden, because of it we can't 396 // generate available_externally vtable for it. 397 // CHECK-TEST16-DAG: @_ZTVN6Test161SE = external unnamed_addr constant 398 // CHECK-TEST16-DAG: @_ZTVN6Test162S2E = available_externally 399 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test161SE = external unnamed_addr constant 400 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test162S2E = available_externally 401 402 struct S { 403 __attribute__((visibility("hidden"))) virtual void doStuff(); 404 }; 405 406 struct S2 { 407 virtual void doStuff(); 408 __attribute__((visibility("hidden"))) void unused(); 409 410 }; 411 412 void test() { 413 S *s = new S; 414 s->doStuff(); 415 416 S2 *s2 = new S2; 417 s2->doStuff(); 418 } 419 } 420 421 namespace Test17 { 422 // This test checks if we emit vtables opportunistically. 423 // CHECK-TEST17-DAG: @_ZTVN6Test171AE = available_externally 424 // CHECK-TEST17-DAG: @_ZTVN6Test171BE = external 425 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test171AE = available_externally 426 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test171BE = available_externally 427 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test171BD2Ev( 428 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test171BD0Ev( 429 430 struct A { 431 virtual void key(); 432 virtual void bar() {} 433 }; 434 435 // We won't gonna use deleting destructor for this type, which will disallow 436 // emitting vtable as available_externally 437 struct B { 438 virtual void key(); 439 virtual ~B() {} 440 }; 441 442 void testcaseA() { 443 A a; 444 a.bar(); // this forces to emit definition of bar 445 } 446 447 void testcaseB() { 448 B b; // This only forces emitting of complete object destructor 449 } 450 451 } // namespace Test17 452 453 namespace Test18 { 454 // Here vtable will be only emitted because it is referenced by assume-load 455 // after the Derived construction. 456 // CHECK-FORCE-EMIT-DAG: @_ZTVN6Test187DerivedE = linkonce_odr unnamed_addr constant {{.*}} @_ZTIN6Test187DerivedE, {{.*}} @_ZN6Test184Base3funEv, {{.*}} @_ZN6Test184BaseD2Ev, {{.*}} @_ZN6Test187DerivedD0Ev 457 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test187DerivedD0Ev 458 // CHECK-FORCE-EMIT-DAG: define linkonce_odr void @_ZN6Test184BaseD2Ev 459 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN6Test184Base3funEv 460 // CHECK-FORCE-EMIT-DAG: @_ZTIN6Test187DerivedE = linkonce_odr constant 461 462 struct Base { 463 virtual int fun() { return 42; } 464 virtual ~Base() { } 465 }; 466 467 struct Derived : Base { 468 Derived(); 469 }; 470 471 int foo() { 472 Derived *der = new Derived(); 473 return der->fun(); 474 } 475 } 476 477 namespace TestTemplates { 478 479 // CHECK-FORCE-EMIT-DAG: @_ZTVN13TestTemplates8TemplateIiEE = linkonce_odr unnamed_addr constant {{.*}} @_ZTIN13TestTemplates8TemplateIiEE, {{.*}} @_ZN13TestTemplates8TemplateIiE3fooEi, {{.*}}@_ZN13TestTemplates8TemplateIiE22thisShouldBeEmittedTooEi, {{.*}}@_ZN13TestTemplates8TemplateIiED1Ev, {{.*}}@_ZN13TestTemplates8TemplateIiED0Ev 480 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates8TemplateIiE22thisShouldBeEmittedTooEi 481 482 template<class T> 483 struct Template { 484 Template(); 485 virtual T foo(T val); 486 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates8TemplateIiE22thisShouldBeEmittedTooEi 487 virtual T thisShouldBeEmittedToo(T val) { return val; } 488 virtual ~Template(); 489 }; 490 491 492 struct NonTemplate { 493 typedef int T; 494 NonTemplate(); 495 virtual T foo(T val); 496 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates11NonTemplate22thisShouldBeEmittedTooEi 497 virtual T thisShouldBeEmittedToo(T val) { return val; } 498 virtual ~NonTemplate(); 499 }; 500 501 // CHECK-FORCE-EMIT-DAG: @_ZTVN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiEE = linkonce_odr {{.*}} @_ZTIN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiEE, {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiE3fooEi, {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiE22thisShouldBeEmittedTooEi, {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiED1Ev, {{.*}} @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiED0Ev 502 503 struct OuterNonTemplate { 504 template<class T> 505 struct NestedTemplateInNonTemplate { 506 NestedTemplateInNonTemplate(); 507 virtual T foo(T val); 508 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates16OuterNonTemplate27NestedTemplateInNonTemplateIiE22thisShouldBeEmittedTooEi 509 virtual T thisShouldBeEmittedToo(T val) { return val; } 510 virtual ~NestedTemplateInNonTemplate(); 511 }; 512 513 struct NestedNonTemplateInNonTemplate { 514 typedef int T; 515 NestedNonTemplateInNonTemplate(); 516 virtual T foo(T val); 517 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates16OuterNonTemplate30NestedNonTemplateInNonTemplate22thisShouldBeEmittedTooEi 518 virtual T thisShouldBeEmittedToo(T val) { return val; } 519 virtual ~NestedNonTemplateInNonTemplate(); 520 }; 521 }; 522 523 template<class> 524 struct OuterTemplate { 525 template<class T> 526 struct NestedTemplateInTemplate { 527 NestedTemplateInTemplate(); 528 virtual T foo(T val); 529 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates13OuterTemplateIlE24NestedTemplateInTemplateIiE22thisShouldBeEmittedTooEi 530 virtual T thisShouldBeEmittedToo(T val) { return val; } 531 virtual ~NestedTemplateInTemplate(); 532 }; 533 534 struct NestedNonTemplateInTemplate { 535 typedef int T; 536 NestedNonTemplateInTemplate(); 537 virtual T foo(T val); 538 // CHECK-FORCE-EMIT-DAG: define linkonce_odr noundef i32 @_ZN13TestTemplates13OuterTemplateIlE27NestedNonTemplateInTemplate22thisShouldBeEmittedTooEi 539 virtual T thisShouldBeEmittedToo(T val) { return val; } 540 virtual ~NestedNonTemplateInTemplate(); 541 }; 542 }; 543 544 template<class T> 545 int use() { 546 T *ptr = new T(); 547 return ptr->foo(42); 548 } 549 550 void test() { 551 use<Template<int> >(); 552 use<OuterTemplate<long>::NestedTemplateInTemplate<int> >(); 553 use<OuterNonTemplate::NestedTemplateInNonTemplate<int> >(); 554 555 use<NonTemplate>(); 556 use<OuterTemplate<long>::NestedNonTemplateInTemplate>(); 557 use<OuterNonTemplate::NestedNonTemplateInNonTemplate>(); 558 } 559 } 560