clang/test/CodeGenCXX/vtable-available-externally.cpp

   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: @_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
  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 // 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
 259 void g(A& a) {
 260   a.foo();
 261   a.bar();
 262 }
 263
 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
 294 void g(D& a) {
 295   C c;
 296   c = a;
 297   a.key();
 298   a.key();
 299 }
 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();
 313   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
 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 *);
 342   ~B() {}
 343 };
 344
 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
 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
 369 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
 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
 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();
 421   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();
 428   virtual ~B() {}
 429 };
 430
 431 void testcaseA() {
 432   A a;
 433   a.bar(); // this forces to emit definition of bar
 434 }
 435
 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 {
 452   virtual int fun() { return 42; }
 453   virtual ~Base() { }
 454 };
 455
 456 struct Derived : Base {
 457   Derived();
 458 };
 459
 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
 476   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
 486   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
 498     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
 507     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
 519     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
 528     virtual T thisShouldBeEmittedToo(T val) { return val; }
 529     virtual ~NestedNonTemplateInTemplate();
 530   };
 531 };
 532
 533 template<class T>
 534 int use() {
 535   T *ptr = new T();
 536   return ptr->foo(42);
 537 }
 538
 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 }