1 // RUN: %clang_cc1 %s -triple=armv7-unknown-unknown -emit-llvm -o - | FileCheck %s
2 // RUN: %clang_cc1 %s -triple=armv7-unknown-unknown -emit-llvm -o - | FileCheck -check-prefix=CHECK-LATE %s
3
4 // The 'a' variants ask for the vtable first.
5 // The 'b' variants ask for the vtable second.
6 // The 'c' variants ask for the vtable third.
7 // We do a separate CHECK-LATE pass because the RTTI definition gets
8 // changed after the fact, which causes reordering of the globals.
9
10 // These are not separated into namespaces because the way that Sema
11 // currently reports namespaces to IR-generation (i.e., en masse for
12 // the entire namespace at once) subverts the ordering that we're
13 // trying to test.
14
15 namespace std { class type_info; }
16 extern void use(const std::type_info &rtti);
17
18 /*** Test0a ******************************************************************/
19
20 struct Test0a {
21 Test0a();
22 virtual inline void foo();
23 virtual void bar();
24 };
25
26 // V-table should be defined externally.
Test0a()27 Test0a::Test0a() { use(typeid(Test0a)); }
28 // CHECK: @_ZTV6Test0a = external unnamed_addr constant
29 // CHECK: @_ZTI6Test0a = external constant
30
31 // This is still not a key function.
foo()32 void Test0a::foo() {}
33
34 /*** Test0b ******************************************************************/
35
36 struct Test0b {
37 Test0b();
38 virtual inline void foo();
39 virtual void bar();
40 };
41
42 // This is still not a key function.
foo()43 void Test0b::foo() {}
44
45 // V-table should be defined externally.
Test0b()46 Test0b::Test0b() { use(typeid(Test0b)); }
47 // CHECK: @_ZTV6Test0b = external unnamed_addr constant
48 // CHECK: @_ZTI6Test0b = external constant
49
50 /*** Test1a ******************************************************************/
51
52 struct Test1a {
53 Test1a();
54 virtual void foo();
55 virtual void bar();
56 };
57
58 // V-table should be defined externally.
Test1a()59 Test1a::Test1a() { use(typeid(Test1a)); }
60 // CHECK: @_ZTV6Test1a = external unnamed_addr constant
61 // CHECK: @_ZTI6Test1a = external constant
62
63 // 'bar' becomes the key function when 'foo' is defined inline.
foo()64 inline void Test1a::foo() {}
65
66 /*** Test1b ******************************************************************/
67
68 struct Test1b {
69 Test1b();
70 virtual void foo();
71 virtual void bar();
72 };
73
74 // 'bar' becomes the key function when 'foo' is defined inline.
foo()75 inline void Test1b::foo() {}
76
77 // V-table should be defined externally.
Test1b()78 Test1b::Test1b() { use(typeid(Test1b)); }
79 // CHECK: @_ZTV6Test1b = external unnamed_addr constant
80 // CHECK: @_ZTI6Test1b = external constant
81
82 /*** Test2a ******************************************************************/
83
84 struct Test2a {
85 Test2a();
86 virtual void foo();
87 virtual void bar();
88 };
89
90 // V-table should be defined with strong linkage.
Test2a()91 Test2a::Test2a() { use(typeid(Test2a)); }
92 // CHECK: @_ZTV6Test2a = unnamed_addr constant
93 // CHECK-LATE: @_ZTS6Test2a = constant
94 // CHECK-LATE: @_ZTI6Test2a = constant
95
96 // 'bar' becomes the key function when 'foo' is defined inline.
bar()97 void Test2a::bar() {}
foo()98 inline void Test2a::foo() {}
99
100 /*** Test2b ******************************************************************/
101
102 struct Test2b {
103 Test2b();
104 virtual void foo();
105 virtual void bar();
106 };
107
108 // 'bar' becomes the key function when 'foo' is defined inline.
bar()109 void Test2b::bar() {}
110
111 // V-table should be defined with strong linkage.
Test2b()112 Test2b::Test2b() { use(typeid(Test2b)); }
113 // CHECK: @_ZTV6Test2b = unnamed_addr constant
114 // CHECK-LATE: @_ZTS6Test2b = constant
115 // CHECK-LATE: @_ZTI6Test2b = constant
116
foo()117 inline void Test2b::foo() {}
118
119 /*** Test2c ******************************************************************/
120
121 struct Test2c {
122 Test2c();
123 virtual void foo();
124 virtual void bar();
125 };
126
127 // 'bar' becomes the key function when 'foo' is defined inline.
bar()128 void Test2c::bar() {}
foo()129 inline void Test2c::foo() {}
130
131 // V-table should be defined with strong linkage.
Test2c()132 Test2c::Test2c() { use(typeid(Test2c)); }
133 // CHECK: @_ZTV6Test2c = unnamed_addr constant
134 // CHECK: @_ZTS6Test2c = constant
135 // CHECK: @_ZTI6Test2c = constant
136
137 /*** Test3a ******************************************************************/
138
139 struct Test3a {
140 Test3a();
141 virtual void foo();
142 virtual void bar();
143 };
144
145 // V-table should be defined with weak linkage.
Test3a()146 Test3a::Test3a() { use(typeid(Test3a)); }
147 // CHECK: @_ZTV6Test3a = linkonce_odr unnamed_addr constant
148 // CHECK-LATE: @_ZTS6Test3a = linkonce_odr constant
149 // CHECK-LATE: @_ZTI6Test3a = linkonce_odr constant
150
151 // There ceases to be a key function after these declarations.
bar()152 inline void Test3a::bar() {}
foo()153 inline void Test3a::foo() {}
154
155 /*** Test3b ******************************************************************/
156
157 struct Test3b {
158 Test3b();
159 virtual void foo();
160 virtual void bar();
161 };
162
163 // There ceases to be a key function after these declarations.
bar()164 inline void Test3b::bar() {}
165
166 // V-table should be defined with weak linkage.
Test3b()167 Test3b::Test3b() { use(typeid(Test3b)); }
168 // CHECK: @_ZTV6Test3b = linkonce_odr unnamed_addr constant
169 // CHECK-LATE: @_ZTS6Test3b = linkonce_odr constant
170 // CHECK-LATE: @_ZTI6Test3b = linkonce_odr constant
171
foo()172 inline void Test3b::foo() {}
173
174 /*** Test3c ******************************************************************/
175
176 struct Test3c {
177 Test3c();
178 virtual void foo();
179 virtual void bar();
180 };
181
182 // There ceases to be a key function after these declarations.
bar()183 inline void Test3c::bar() {}
foo()184 inline void Test3c::foo() {}
185
186 // V-table should be defined with weak linkage.
Test3c()187 Test3c::Test3c() { use(typeid(Test3c)); }
188 // CHECK: @_ZTV6Test3c = linkonce_odr unnamed_addr constant
189 // CHECK: @_ZTS6Test3c = linkonce_odr constant
190 // CHECK: @_ZTI6Test3c = linkonce_odr constant
191
192 /*** Test4a ******************************************************************/
193
194 template <class T> struct Test4a {
195 Test4a();
196 virtual void foo();
197 virtual void bar();
198 };
199
200 // V-table should be defined with weak linkage.
Test4a()201 template <> Test4a<int>::Test4a() { use(typeid(Test4a)); }
202 // CHECK: @_ZTV6Test4aIiE = linkonce_odr unnamed_addr constant
203 // CHECK: @_ZTS6Test4aIiE = linkonce_odr constant
204 // CHECK: @_ZTI6Test4aIiE = linkonce_odr constant
205
206 // There ceases to be a key function after these declarations.
bar()207 template <> inline void Test4a<int>::bar() {}
foo()208 template <> inline void Test4a<int>::foo() {}
209
210 /*** Test4b ******************************************************************/
211
212 template <class T> struct Test4b {
213 Test4b();
214 virtual void foo();
215 virtual void bar();
216 };
217
218 // There ceases to be a key function after these declarations.
bar()219 template <> inline void Test4b<int>::bar() {}
220
221 // V-table should be defined with weak linkage.
Test4b()222 template <> Test4b<int>::Test4b() { use(typeid(Test4b)); }
223 // CHECK: @_ZTV6Test4bIiE = linkonce_odr unnamed_addr constant
224 // CHECK: @_ZTS6Test4bIiE = linkonce_odr constant
225 // CHECK: @_ZTI6Test4bIiE = linkonce_odr constant
226
foo()227 template <> inline void Test4b<int>::foo() {}
228
229 /*** Test4c ******************************************************************/
230
231 template <class T> struct Test4c {
232 Test4c();
233 virtual void foo();
234 virtual void bar();
235 };
236
237 // There ceases to be a key function after these declarations.
bar()238 template <> inline void Test4c<int>::bar() {}
foo()239 template <> inline void Test4c<int>::foo() {}
240
241 // V-table should be defined with weak linkage.
Test4c()242 template <> Test4c<int>::Test4c() { use(typeid(Test4c)); }
243 // CHECK: @_ZTV6Test4cIiE = linkonce_odr unnamed_addr constant
244 // CHECK: @_ZTS6Test4cIiE = linkonce_odr constant
245 // CHECK: @_ZTI6Test4cIiE = linkonce_odr constant
246
247 /*** Test5a ******************************************************************/
248
249 template <class T> struct Test5a {
250 Test5a();
251 virtual void foo();
252 virtual void bar();
253 };
254
255 template <> inline void Test5a<int>::bar();
256 template <> inline void Test5a<int>::foo();
257
258 // V-table should be defined with weak linkage.
Test5a()259 template <> Test5a<int>::Test5a() { use(typeid(Test5a)); }
260 // CHECK: @_ZTV6Test5aIiE = linkonce_odr unnamed_addr constant
261 // CHECK: @_ZTS6Test5aIiE = linkonce_odr constant
262 // CHECK: @_ZTI6Test5aIiE = linkonce_odr constant
263
264 // There ceases to be a key function after these declarations.
bar()265 template <> inline void Test5a<int>::bar() {}
foo()266 template <> inline void Test5a<int>::foo() {}
267
268 /*** Test5b ******************************************************************/
269
270 template <class T> struct Test5b {
271 Test5b();
272 virtual void foo();
273 virtual void bar();
274 };
275
276 // There ceases to be a key function after these declarations.
277 template <> inline void Test5a<int>::bar();
bar()278 template <> inline void Test5b<int>::bar() {}
279
280 // V-table should be defined with weak linkage.
Test5b()281 template <> Test5b<int>::Test5b() { use(typeid(Test5b)); }
282 // CHECK: @_ZTV6Test5bIiE = linkonce_odr unnamed_addr constant
283 // CHECK: @_ZTS6Test5bIiE = linkonce_odr constant
284 // CHECK: @_ZTI6Test5bIiE = linkonce_odr constant
285
286 template <> inline void Test5a<int>::foo();
foo()287 template <> inline void Test5b<int>::foo() {}
288
289 /*** Test5c ******************************************************************/
290
291 template <class T> struct Test5c {
292 Test5c();
293 virtual void foo();
294 virtual void bar();
295 };
296
297 // There ceases to be a key function after these declarations.
298 template <> inline void Test5a<int>::bar();
299 template <> inline void Test5a<int>::foo();
bar()300 template <> inline void Test5c<int>::bar() {}
foo()301 template <> inline void Test5c<int>::foo() {}
302
303 // V-table should be defined with weak linkage.
Test5c()304 template <> Test5c<int>::Test5c() { use(typeid(Test5c)); }
305 // CHECK: @_ZTV6Test5cIiE = linkonce_odr unnamed_addr constant
306 // CHECK: @_ZTS6Test5cIiE = linkonce_odr constant
307 // CHECK: @_ZTI6Test5cIiE = linkonce_odr constant
308