249 lines · cpp
1// RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases | FileCheck --check-prefix=NOOPT %s2 3// RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes > %t4// RUN: FileCheck --check-prefix=CHECK1 --input-file=%t %s5// RUN: FileCheck --check-prefix=CHECK2 --input-file=%t %s6// RUN: FileCheck --check-prefix=CHECK3 --input-file=%t %s7// RUN: FileCheck --check-prefix=CHECK4 --input-file=%t %s8// RUN: FileCheck --check-prefix=CHECK5 --input-file=%t %s9// RUN: FileCheck --check-prefix=CHECK6 --input-file=%t %s10 11// RUN: %clang_cc1 %s -triple i686-pc-windows-gnu -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes | FileCheck --check-prefix=COFF %s12 13namespace test1 {14// Test that we produce the appropriate comdats when creating aliases to15// weak_odr constructors and destructors.16 17// CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr unnamed_addr alias void {{.*}} @_ZN5test16foobarIvEC2Ev18// CHECK1: @_ZN5test16foobarIvED1Ev = weak_odr unnamed_addr alias void (ptr), ptr @_ZN5test16foobarIvED2Ev19// CHECK1: define weak_odr void @_ZN5test16foobarIvEC2Ev({{.*}} comdat($_ZN5test16foobarIvEC5Ev)20// CHECK1: define weak_odr void @_ZN5test16foobarIvED2Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev)21// CHECK1: define weak_odr void @_ZN5test16foobarIvED0Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev)22// CHECK1-NOT: comdat23 24// COFF doesn't support comdats with arbitrary names (C5/D5).25// COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvEC2Ev({{.*}} comdat align26// COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvEC1Ev({{.*}} comdat align27// COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvED2Ev({{.*}} comdat align28// COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvED0Ev({{.*}} comdat align29 30template <typename T>31struct foobar {32 foobar() {}33 virtual ~foobar() {}34};35 36template struct foobar<void>;37}38 39namespace test2 {40// test that when the destrucor is linkonce_odr we just replace every use of41// C1 with C2.42 43// CHECK1: define internal void @__cxx_global_var_init()44// CHECK1: call void @_ZN5test26foobarIvEC2Ev45// CHECK1: define linkonce_odr void @_ZN5test26foobarIvEC2Ev({{.*}} comdat align46void g();47template <typename T> struct foobar {48 foobar() { g(); }49};50foobar<void> x;51}52 53namespace test3 {54// test that instead of an internal alias we just use the other destructor55// directly.56 57// CHECK1: define internal void @__cxx_global_var_init.1()58// CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test312_GLOBAL__N_11AD2Ev59// CHECK1: define internal void @_ZN5test312_GLOBAL__N_11AD2Ev(60namespace {61struct A {62 ~A() {}63};64 65struct B : public A {};66}67 68B x;69}70 71namespace test4 {72 // Test that we don't produce aliases from B to A. We cannot because we cannot73 // guarantee that they will be present in every TU. Instead, we just call74 // A's destructor directly.75 76 // CHECK1: define internal void @__cxx_global_var_init.2()77 // CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test41AD2Ev78 // CHECK1: define linkonce_odr void @_ZN5test41AD2Ev({{.*}} comdat align79 80 // test that we don't do this optimization at -O0 so that the debugger can81 // see both destructors.82 // NOOPT: define internal void @__cxx_global_var_init.2()83 // NOOPT: call i32 @__cxa_atexit{{.*}}@_ZN5test41BD2Ev84 // NOOPT: define linkonce_odr void @_ZN5test41BD2Ev({{.*}} comdat align85 struct A {86 virtual ~A() {}87 };88 struct B : public A{89 ~B() {}90 };91 B X;92}93 94namespace test5 {95 // similar to test4, but with an internal B.96 97 // CHECK2: define internal void @__cxx_global_var_init.3()98 // CHECK2: call i32 @__cxa_atexit{{.*}}_ZN5test51AD2Ev99 // CHECK2: define linkonce_odr void @_ZN5test51AD2Ev({{.*}} comdat align100 struct A {101 virtual ~A() {}102 };103 namespace {104 struct B : public A{105 ~B() {}106 };107 }108 B X;109}110 111namespace test6 {112 // Test that we use ~A directly, even when ~A is not defined. The symbol for113 // ~B would have been internal and still contain a reference to ~A.114 struct A {115 virtual ~A();116 };117 namespace {118 struct B : public A {119 ~B() {}120 };121 }122 B X;123 // CHECK3: define internal void @__cxx_global_var_init.4()124 // CHECK3: call i32 @__cxa_atexit({{.*}}@_ZN5test61AD2Ev125}126 127namespace test7 {128 // Test that we don't produce an alias from ~B to ~A<int> (or crash figuring129 // out if we should).130 // pr17875.131 // CHECK3: define{{.*}} void @_ZN5test71BD2Ev132 template <typename> struct A {133 ~A() {}134 };135 class B : A<int> {136 ~B();137 };138 template class A<int>;139 B::~B() {}140}141 142namespace test8 {143 // Test that we replace ~zed with ~bar which is an alias to ~foo.144 // CHECK4: @_ZN5test83barD2Ev ={{.*}} unnamed_addr alias {{.*}} @_ZN5test83fooD2Ev145 // CHECK4: define internal void @__cxx_global_var_init.5()146 // CHECK4: call i32 @__cxa_atexit({{.*}}@_ZN5test83barD2Ev147 struct foo {148 ~foo();149 };150 foo::~foo() {}151 struct bar : public foo {152 ~bar();153 };154 bar::~bar() {}155 struct zed : public bar {};156 zed foo;157}158 159namespace test9 {160struct foo {161 __attribute__((stdcall)) ~foo() {162 }163};164 165struct bar : public foo {};166 167void zed() {168 // Test that we produce a call to bar's destructor. We used to call foo's, but169 // it has a different calling conversion.170 // CHECK4: call void @_ZN5test93barD2Ev171 bar ptr;172}173}174 175// CHECK5: @_ZTV1C = linkonce_odr unnamed_addr constant { [4 x ptr] } {{[^@]*}}@_ZTI1C, {{[^@]*}}@_ZN1CD2Ev, {{[^@]*}}@_ZN1CD0Ev]176// r194296 replaced C::~C with B::~B without emitting the later.177 178class A {179public:180 A(int);181 virtual ~A();182};183 184template <class>185class B : A {186public:187 B()188 : A(0) {189 }190 __attribute__((always_inline)) ~B() {191 }192};193 194extern template class B<char>;195 196class C : B<char> {197};198 199void200fn1() {201 new C;202}203 204namespace test10 {205// Test that if a destructor is in a comdat, we don't try to emit is as an206// alias to a base class destructor.207struct bar {208 ~bar();209};210bar::~bar() {211}212} // closing the namespace causes ~bar to be sent to CodeGen213namespace test10 {214template <typename T>215struct foo : public bar {216 ~foo();217};218template <typename T>219foo<T>::~foo() {}220template class foo<int>;221// CHECK5: define weak_odr void @_ZN6test103fooIiED2Ev({{.*}} comdat($_ZN6test103fooIiED5Ev)222}223 224namespace test11 {225// Test that when we don't have to worry about COMDATs we produce an alias226// from complate to base and from base to base class base.227struct bar {228 ~bar();229};230bar::~bar() {}231struct foo : public bar {232 ~foo();233};234foo::~foo() {}235// CHECK6: @_ZN6test113fooD2Ev ={{.*}} unnamed_addr alias {{.*}} @_ZN6test113barD2Ev236// CHECK6: @_ZN6test113fooD1Ev ={{.*}} unnamed_addr alias {{.*}} @_ZN6test113fooD2Ev237}238 239namespace test12 {240template <int>241struct foo {242 ~foo() { delete this; }243};244 245template class foo<1>;246// CHECK6: @_ZN6test123fooILi1EED1Ev = weak_odr unnamed_addr alias {{.*}} @_ZN6test123fooILi1EED2Ev247// CHECK6: define weak_odr void @_ZN6test123fooILi1EED2Ev({{.*}}) {{.*}} comdat($_ZN6test123fooILi1EED5Ev)248}249