Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1 | // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases | FileCheck --check-prefix=NOOPT %s |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 2 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 3 | // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-optzns > %t |
| 4 | // RUN: FileCheck --check-prefix=CHECK1 --input-file=%t %s |
| 5 | // RUN: FileCheck --check-prefix=CHECK2 --input-file=%t %s |
| 6 | // RUN: FileCheck --check-prefix=CHECK3 --input-file=%t %s |
| 7 | // RUN: FileCheck --check-prefix=CHECK4 --input-file=%t %s |
| 8 | // RUN: FileCheck --check-prefix=CHECK5 --input-file=%t %s |
| 9 | // RUN: FileCheck --check-prefix=CHECK6 --input-file=%t %s |
| 10 | |
| 11 | // RUN: %clang_cc1 %s -triple i686-pc-windows-gnu -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-optzns | FileCheck --check-prefix=COFF %s |
Bill Wendling | cc05778 | 2013-11-25 05:40:33 +0000 | [diff] [blame] | 12 | |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 13 | namespace test1 { |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 14 | // Test that we produce the apropriate comdats when creating aliases to |
| 15 | // weak_odr constructors and destructors. |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 16 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 17 | // CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr alias void {{.*}} @_ZN5test16foobarIvEC2Ev |
| 18 | // CHECK1: @_ZN5test16foobarIvED1Ev = weak_odr alias void (%"struct.test1::foobar"*)* @_ZN5test16foobarIvED2Ev |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 19 | // 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) |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 22 | // CHECK1-NOT: comdat |
Rafael Espindola | 610616c | 2013-11-12 22:06:46 +0000 | [diff] [blame] | 23 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 24 | // COFF doesn't support comdats with arbitrary names (C5/D5). |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 25 | // COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvEC2Ev({{.*}} comdat align |
| 26 | // COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvEC1Ev({{.*}} comdat align |
| 27 | // COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvED2Ev({{.*}} comdat align |
| 28 | // COFF: define weak_odr {{.*}} void @_ZN5test16foobarIvED0Ev({{.*}} comdat align |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 29 | |
| 30 | template <typename T> |
| 31 | struct foobar { |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 32 | foobar() {} |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 33 | virtual ~foobar() {} |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 34 | }; |
| 35 | |
| 36 | template struct foobar<void>; |
| 37 | } |
| 38 | |
| 39 | namespace test2 { |
Rafael Espindola | 61a0a75 | 2013-11-05 21:37:29 +0000 | [diff] [blame] | 40 | // test that when the destrucor is linkonce_odr we just replace every use of |
| 41 | // C1 with C2. |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 42 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 43 | // CHECK1: define internal void @__cxx_global_var_init() |
| 44 | // CHECK1: call void @_ZN5test26foobarIvEC2Ev |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 45 | // CHECK1: define linkonce_odr void @_ZN5test26foobarIvEC2Ev({{.*}} comdat align |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 46 | void g(); |
| 47 | template <typename T> struct foobar { |
| 48 | foobar() { g(); } |
| 49 | }; |
| 50 | foobar<void> x; |
| 51 | } |
| 52 | |
| 53 | namespace test3 { |
Rafael Espindola | 1b9c024 | 2013-11-08 23:46:20 +0000 | [diff] [blame] | 54 | // test that instead of an internal alias we just use the other destructor |
| 55 | // directly. |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 56 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 57 | // CHECK1: define internal void @__cxx_global_var_init1() |
| 58 | // CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test312_GLOBAL__N_11AD2Ev |
| 59 | // CHECK1: define internal void @_ZN5test312_GLOBAL__N_11AD2Ev( |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 60 | namespace { |
| 61 | struct A { |
| 62 | ~A() {} |
| 63 | }; |
| 64 | |
| 65 | struct B : public A {}; |
| 66 | } |
| 67 | |
| 68 | B x; |
| 69 | } |
| 70 | |
| 71 | namespace test4 { |
| 72 | // Test that we don't produce aliases from B to A. We cannot because we cannot |
Rafael Espindola | 0171c6b | 2013-11-08 22:59:46 +0000 | [diff] [blame] | 73 | // guarantee that they will be present in every TU. Instead, we just call |
| 74 | // A's destructor directly. |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 75 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 76 | // CHECK1: define internal void @__cxx_global_var_init2() |
| 77 | // CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test41AD2Ev |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 78 | // CHECK1: define linkonce_odr void @_ZN5test41AD2Ev({{.*}} comdat align |
Rafael Espindola | dc8e938 | 2013-11-13 23:20:45 +0000 | [diff] [blame] | 79 | |
| 80 | // test that we don't do this optimization at -O0 so that the debugger can |
| 81 | // see both destructors. |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 82 | // NOOPT: define internal void @__cxx_global_var_init2() |
| 83 | // NOOPT: call i32 @__cxa_atexit{{.*}}@_ZN5test41BD2Ev |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 84 | // NOOPT: define linkonce_odr void @_ZN5test41BD2Ev({{.*}} comdat align |
Rafael Espindola | 71fdc12 | 2013-11-04 18:38:59 +0000 | [diff] [blame] | 85 | struct A { |
| 86 | virtual ~A() {} |
| 87 | }; |
| 88 | struct B : public A{ |
| 89 | ~B() {} |
| 90 | }; |
| 91 | B X; |
| 92 | } |
Rafael Espindola | 1b9c024 | 2013-11-08 23:46:20 +0000 | [diff] [blame] | 93 | |
| 94 | namespace test5 { |
| 95 | // similar to test4, but with an internal B. |
| 96 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 97 | // CHECK2: define internal void @__cxx_global_var_init3() |
| 98 | // CHECK2: call i32 @__cxa_atexit{{.*}}_ZN5test51AD2Ev |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 99 | // CHECK2: define linkonce_odr void @_ZN5test51AD2Ev({{.*}} comdat align |
Rafael Espindola | 1b9c024 | 2013-11-08 23:46:20 +0000 | [diff] [blame] | 100 | struct A { |
| 101 | virtual ~A() {} |
| 102 | }; |
| 103 | namespace { |
| 104 | struct B : public A{ |
| 105 | ~B() {} |
| 106 | }; |
| 107 | } |
| 108 | B X; |
| 109 | } |
Rafael Espindola | 6e84e92 | 2013-11-09 01:57:21 +0000 | [diff] [blame] | 110 | |
| 111 | namespace test6 { |
| 112 | // Test that we use ~A directly, even when ~A is not defined. The symbol for |
| 113 | // ~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; |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 123 | // CHECK3: define internal void @__cxx_global_var_init4() |
| 124 | // CHECK3: call i32 @__cxa_atexit({{.*}}@_ZN5test61AD2Ev |
Rafael Espindola | 6e84e92 | 2013-11-09 01:57:21 +0000 | [diff] [blame] | 125 | } |
Rafael Espindola | 47a2ab9 | 2013-11-11 19:35:06 +0000 | [diff] [blame] | 126 | |
| 127 | namespace test7 { |
| 128 | // Test that we don't produce an alias from ~B to ~A<int> (or crash figuring |
| 129 | // out if we should). |
| 130 | // pr17875. |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 131 | // CHECK3: define void @_ZN5test71BD2Ev |
Rafael Espindola | 47a2ab9 | 2013-11-11 19:35:06 +0000 | [diff] [blame] | 132 | template <typename> struct A { |
| 133 | ~A() {} |
| 134 | }; |
| 135 | class B : A<int> { |
| 136 | ~B(); |
| 137 | }; |
| 138 | template class A<int>; |
| 139 | B::~B() {} |
| 140 | } |
Rafael Espindola | 964bfa1 | 2013-11-11 22:55:13 +0000 | [diff] [blame] | 141 | |
| 142 | namespace test8 { |
| 143 | // Test that we replace ~zed with ~bar which is an alias to ~foo. |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 144 | // CHECK4: @_ZN5test83barD2Ev = alias {{.*}} @_ZN5test83fooD2Ev |
| 145 | // CHECK4: define internal void @__cxx_global_var_init5() |
| 146 | // CHECK4: call i32 @__cxa_atexit({{.*}}@_ZN5test83barD2Ev |
Rafael Espindola | 964bfa1 | 2013-11-11 22:55:13 +0000 | [diff] [blame] | 147 | 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 | } |
Bill Wendling | cc05778 | 2013-11-25 05:40:33 +0000 | [diff] [blame] | 158 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 159 | namespace test9 { |
| 160 | struct foo { |
| 161 | __attribute__((stdcall)) ~foo() { |
| 162 | } |
| 163 | }; |
| 164 | |
| 165 | struct bar : public foo {}; |
| 166 | |
| 167 | void zed() { |
| 168 | // Test that we produce a call to bar's destructor. We used to call foo's, but |
| 169 | // it has a different calling conversion. |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 170 | // CHECK4: call void @_ZN5test93barD2Ev |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 171 | bar ptr; |
| 172 | } |
| 173 | } |
| 174 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 175 | // CHECK5: @_ZTV1C = linkonce_odr unnamed_addr constant [4 x i8*] [{{[^@]*}}@_ZTI1C {{[^@]*}}@_ZN1CD2Ev {{[^@]*}}@_ZN1CD0Ev {{[^@]*}}] |
Bill Wendling | cc05778 | 2013-11-25 05:40:33 +0000 | [diff] [blame] | 176 | // r194296 replaced C::~C with B::~B without emitting the later. |
| 177 | |
| 178 | class A { |
| 179 | public: |
| 180 | A(int); |
| 181 | virtual ~A(); |
| 182 | }; |
| 183 | |
| 184 | template <class> |
| 185 | class B : A { |
| 186 | public: |
| 187 | B() |
| 188 | : A(0) { |
| 189 | } |
| 190 | __attribute__((always_inline)) ~B() { |
| 191 | } |
| 192 | }; |
| 193 | |
| 194 | extern template class B<char>; |
| 195 | |
| 196 | class C : B<char> { |
| 197 | }; |
| 198 | |
| 199 | void |
| 200 | fn1() { |
| 201 | new C; |
| 202 | } |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 203 | |
| 204 | namespace test10 { |
| 205 | // Test that if a destructor is in a comdat, we don't try to emit is as an |
| 206 | // alias to a base class destructor. |
| 207 | struct bar { |
| 208 | ~bar(); |
| 209 | }; |
| 210 | bar::~bar() { |
| 211 | } |
| 212 | } // closing the namespace causes ~bar to be sent to CodeGen |
| 213 | namespace test10 { |
| 214 | template <typename T> |
| 215 | struct foo : public bar { |
| 216 | ~foo(); |
| 217 | }; |
| 218 | template <typename T> |
| 219 | foo<T>::~foo() {} |
| 220 | template class foo<int>; |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 221 | // CHECK5: define weak_odr void @_ZN6test103fooIiED2Ev({{.*}} comdat($_ZN6test103fooIiED5Ev) |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | namespace test11 { |
| 225 | // Test that when we don't have to worry about COMDATs we produce an alias |
| 226 | // from complate to base and from base to base class base. |
| 227 | struct bar { |
| 228 | ~bar(); |
| 229 | }; |
| 230 | bar::~bar() {} |
| 231 | struct foo : public bar { |
| 232 | ~foo(); |
| 233 | }; |
| 234 | foo::~foo() {} |
| 235 | // CHECK6: @_ZN6test113fooD2Ev = alias {{.*}} @_ZN6test113barD2Ev |
| 236 | // CHECK6: @_ZN6test113fooD1Ev = alias {{.*}} @_ZN6test113fooD2Ev |
| 237 | } |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 238 | |
| 239 | namespace test12 { |
| 240 | template <int> |
| 241 | struct foo { |
| 242 | ~foo() { delete this; } |
| 243 | }; |
| 244 | |
| 245 | template class foo<1>; |
| 246 | // CHECK6: @_ZN6test123fooILi1EED1Ev = weak_odr alias {{.*}} @_ZN6test123fooILi1EED2Ev |
| 247 | // CHECK6: define weak_odr void @_ZN6test123fooILi1EED2Ev({{.*}}) {{.*}} comdat($_ZN6test123fooILi1EED5Ev) |
| 248 | } |