1 // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases | FileCheck --check-prefix=NOOPT %s
2 
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
12 
13 namespace test1 {
14 // Test that we produce the apropriate comdats when creating aliases to
15 // weak_odr constructors and destructors.
16 
17 // CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr alias void {{.*}} @_ZN5test16foobarIvEC2Ev
18 // CHECK1: @_ZN5test16foobarIvED1Ev = weak_odr alias void (%"struct.test1::foobar"*), void (%"struct.test1::foobar"*)* @_ZN5test16foobarIvED2Ev
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)
22 // CHECK1-NOT: comdat
23 
24 // COFF doesn't support comdats with arbitrary names (C5/D5).
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
29 
30 template <typename T>
31 struct foobar {
32   foobar() {}
33   virtual ~foobar() {}
34 };
35 
36 template struct foobar<void>;
37 }
38 
39 namespace test2 {
40 // test that when the destrucor is linkonce_odr we just replace every use of
41 // C1 with C2.
42 
43 // CHECK1: define internal void @__cxx_global_var_init()
44 // CHECK1: call void @_ZN5test26foobarIvEC2Ev
45 // CHECK1: define linkonce_odr void @_ZN5test26foobarIvEC2Ev({{.*}} comdat align
46 void g();
47 template <typename T> struct foobar {
48   foobar() { g(); }
49 };
50 foobar<void> x;
51 }
52 
53 namespace test3 {
54 // test that instead of an internal alias we just use the other destructor
55 // directly.
56 
57 // CHECK1: define internal void @__cxx_global_var_init.1()
58 // CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test312_GLOBAL__N_11AD2Ev
59 // CHECK1: define internal void @_ZN5test312_GLOBAL__N_11AD2Ev(
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
73   // guarantee that they will be present in every TU. Instead, we just call
74   // A's destructor directly.
75 
76   // CHECK1: define internal void @__cxx_global_var_init.2()
77   // CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test41AD2Ev
78   // CHECK1: define linkonce_odr void @_ZN5test41AD2Ev({{.*}} comdat align
79 
80   // test that we don't do this optimization at -O0 so that the debugger can
81   // see both destructors.
82   // NOOPT: define internal void @__cxx_global_var_init.2()
83   // NOOPT: call i32 @__cxa_atexit{{.*}}@_ZN5test41BD2Ev
84   // NOOPT: define linkonce_odr void @_ZN5test41BD2Ev({{.*}} comdat align
85   struct A {
86     virtual ~A() {}
87   };
88   struct B : public A{
89     ~B() {}
90   };
91   B X;
92 }
93 
94 namespace 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{{.*}}_ZN5test51AD2Ev
99   // CHECK2: define linkonce_odr void @_ZN5test51AD2Ev({{.*}} comdat align
100   struct A {
101     virtual ~A() {}
102   };
103   namespace {
104   struct B : public A{
105     ~B() {}
106   };
107   }
108   B X;
109 }
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;
123   // CHECK3: define internal void @__cxx_global_var_init.4()
124   // CHECK3: call i32 @__cxa_atexit({{.*}}@_ZN5test61AD2Ev
125 }
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.
131   // CHECK3: define void @_ZN5test71BD2Ev
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 }
141 
142 namespace test8 {
143   // Test that we replace ~zed with ~bar which is an alias to ~foo.
144   // CHECK4: @_ZN5test83barD2Ev = alias {{.*}} @_ZN5test83fooD2Ev
145   // CHECK4: define internal void @__cxx_global_var_init.5()
146   // CHECK4: call i32 @__cxa_atexit({{.*}}@_ZN5test83barD2Ev
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 }
158 
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.
170   // CHECK4: call void @_ZN5test93barD2Ev
171   bar ptr;
172 }
173 }
174 
175 // CHECK5: @_ZTV1C = linkonce_odr unnamed_addr constant [4 x i8*] [{{[^@]*}}@_ZTI1C {{[^@]*}}@_ZN1CD2Ev {{[^@]*}}@_ZN1CD0Ev {{[^@]*}}]
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 }
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>;
221 // CHECK5: define weak_odr void @_ZN6test103fooIiED2Ev({{.*}} comdat($_ZN6test103fooIiED5Ev)
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 }
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 }
249