1 // RUN: %clang_cc1 -w -triple x86_64-elf-gnu -emit-llvm -o - %s -std=c++11 | FileCheck %s
2
3 // FIXME: The padding in all these objects should be zero-initialized.
4 namespace StructUnion {
5 struct A {
6 int n;
7 double d;
8 union U {
U(int x)9 constexpr U(int x) : x(x) {}
U(const char * y)10 constexpr U(const char *y) : y(y) {}
11 int x;
12 const char *y;
13 } u;
14
AStructUnion::A15 constexpr A(int n, double d, int x) : n(n), d(d), u(x) {}
AStructUnion::A16 constexpr A(int n, double d, const char *y) : n(n), d(d), u(y) {}
17 };
18
19 // CHECK: @_ZN11StructUnion1aE = constant {{.*}} { i32 1, double 2.000000e+00, {{.*}} { i32 3, [4 x i8] undef } }
20 extern constexpr A a(1, 2.0, 3);
21
22 // CHECK: @_ZN11StructUnion1bE = constant {{.*}} { i32 4, double 5.000000e+00, {{.*}} { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0) } }
23 extern constexpr A b(4, 5, "hello");
24
25 struct B {
26 int n;
27 };
28
29 // CHECK: @_ZN11StructUnion1cE = global {{.*}} zeroinitializer
30 // CHECK: @_ZN11StructUnion2c2E = global {{.*}} zeroinitializer
31 B c;
32 B c2 = B();
33
34 // CHECK: @_ZN11StructUnion1dE = global {{.*}} zeroinitializer
35 B d[10];
36
37 struct C {
CStructUnion::C38 constexpr C() : c(0) {}
39 int c;
40 };
41
42 // CHECK: @_ZN11StructUnion1eE = global {{.*}} zeroinitializer
43 C e[10];
44
45 struct D {
DStructUnion::D46 constexpr D() : d(5) {}
47 int d;
48 };
49
50 // CHECK: @_ZN11StructUnion1fE = global {{.*}} { i32 5 }
51 D f;
52
53 union E {
54 int a;
55 void *b = &f;
56 };
57
58 // CHECK: @_ZN11StructUnion1gE = global {{.*}} @_ZN11StructUnion1fE
59 E g;
60
61 // CHECK: @_ZN11StructUnion1hE = global {{.*}} @_ZN11StructUnion1fE
62 E h = E();
63 }
64
65 namespace BaseClass {
66 template<typename T, unsigned> struct X : T {};
67 struct C { char c = 1; };
68 template<unsigned... Ns> struct Cs : X<C,Ns>... {};
69 struct N { int n = 3; };
70 struct D { double d = 4.0; };
71
72 template<typename ...Ts>
TestBaseClass::Test73 struct Test : Ts... { constexpr Test() : Ts()..., n(5) {} int n; };
74
75 using Test1 = Test<N, C, Cs<1,2>, D, X<C,1>>;
76 // CHECK: @_ZN9BaseClass2t1E = constant {{.*}} { i32 3, i8 1, i8 1, i8 1, double 4.000000e+00, i8 1, i32 5 }, align 8
77 extern constexpr Test1 t1 = Test1();
78
79 struct DN : D, N {};
80 struct DND : DN, X<D,0> {};
81 struct DNN : DN, X<N,0> {};
82 // CHECK: @_ZN9BaseClass3dndE = constant {{.*}} { double 4.000000e+00, i32 3, double 4.000000e+00 }
83 extern constexpr DND dnd = DND();
84 // Note, N subobject is laid out in DN subobject's tail padding.
85 // CHECK: @_ZN9BaseClass3dnnE = constant {{.*}} { double 4.000000e+00, i32 3, i32 3 }
86 extern constexpr DNN dnn = DNN();
87
88 struct E {};
89 struct Test2 : X<E,0>, X<E,1>, X<E,2>, X<E,3> {};
90 // CHECK: @_ZN9BaseClass2t2E = constant {{.*}} undef
91 extern constexpr Test2 t2 = Test2();
92
93 struct __attribute((packed)) PackedD { double y = 2; };
Test3BaseClass::Test394 struct Test3 : C, PackedD { constexpr Test3() {} };
95 // CHECK: @_ZN9BaseClass2t3E = constant <{ i8, double }> <{ i8 1, double 2.000000e+00 }>
96 extern constexpr Test3 t3 = Test3();
97 }
98
99 namespace Array {
100 // CHECK: @_ZN5Array3arrE = constant [2 x i32] [i32 4, i32 0]
101 extern constexpr int arr[2] = { 4 };
102
103 // CHECK: @_ZN5Array1cE = constant [6 x [4 x i8]] [{{.*}} c"foo\00", [4 x i8] c"a\00\00\00", [4 x i8] c"bar\00", [4 x i8] c"xyz\00", [4 x i8] c"b\00\00\00", [4 x i8] c"123\00"]
104 extern constexpr char c[6][4] = { "foo", "a", { "bar" }, { 'x', 'y', 'z' }, { "b" }, '1', '2', '3' };
105
106 // CHECK: @_ZN5Array2ucE = constant [4 x i8] c"foo\00"
107 extern constexpr unsigned char uc[] = { "foo" };
108
CArray::C109 struct C { constexpr C() : n(5) {} int n, m = 3 * n + 1; };
110 // CHECK: @_ZN5Array5ctorsE = constant [3 x {{.*}}] [{{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }]
111 extern const C ctors[3];
112 constexpr C ctors[3];
113
114 // CHECK: @_ZN5Array1dE = constant {{.*}} { [2 x i32] [i32 1, i32 2], [3 x i32] [i32 3, i32 4, i32 5] }
115 struct D { int n[2]; int m[3]; } extern constexpr d = { 1, 2, 3, 4, 5 };
116
117 struct E {
118 char c[4];
119 char d[4];
EArray::E120 constexpr E() : c("foo"), d("x") {}
121 };
122 // CHECK: @_ZN5Array1eE = constant {{.*}} { [4 x i8] c"foo\00", [4 x i8] c"x\00\00\00" }
123 extern constexpr E e = E();
124
125 // PR13290
FArray::F126 struct F { constexpr F() : n(4) {} int n; };
127 // CHECK: @_ZN5Array2f1E = global {{.*}} zeroinitializer
128 F f1[1][1][0] = { };
129 // CHECK: @_ZN5Array2f2E = global {{.* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4}}
130 F f2[2][2][2] = { };
131 }
132
133 namespace MemberPtr {
134 struct B1 {
135 int a, b;
136 virtual void f();
137 void g();
138 };
139 struct B2 {
140 int c, d;
141 virtual void h();
142 void i();
143 };
144 struct C : B1 {
145 int e;
146 virtual void j();
147 void k();
148 };
149 struct D : C, B2 {
150 int z;
151 virtual void l();
152 void m();
153 };
154
155 // CHECK: @_ZN9MemberPtr2daE = constant i64 8
156 // CHECK: @_ZN9MemberPtr2dbE = constant i64 12
157 // CHECK: @_ZN9MemberPtr2dcE = constant i64 32
158 // CHECK: @_ZN9MemberPtr2ddE = constant i64 36
159 // CHECK: @_ZN9MemberPtr2deE = constant i64 16
160 // CHECK: @_ZN9MemberPtr2dzE = constant i64 40
161 extern constexpr int (D::*da) = &B1::a;
162 extern constexpr int (D::*db) = &C::b;
163 extern constexpr int (D::*dc) = &B2::c;
164 extern constexpr int (D::*dd) = &D::d;
165 extern constexpr int (D::*de) = &C::e;
166 extern constexpr int (D::*dz) = &D::z;
167
168 // CHECK: @_ZN9MemberPtr2baE = constant i64 8
169 // CHECK: @_ZN9MemberPtr2bbE = constant i64 12
170 // CHECK: @_ZN9MemberPtr2bcE = constant i64 8
171 // CHECK: @_ZN9MemberPtr2bdE = constant i64 12
172 // CHECK: @_ZN9MemberPtr2beE = constant i64 16
173 // CHECK: @_ZN9MemberPtr3b1zE = constant i64 40
174 // CHECK: @_ZN9MemberPtr3b2zE = constant i64 16
175 extern constexpr int (B1::*ba) = (int(B1::*))&B1::a;
176 extern constexpr int (B1::*bb) = (int(B1::*))&C::b;
177 extern constexpr int (B2::*bc) = (int(B2::*))&B2::c;
178 extern constexpr int (B2::*bd) = (int(B2::*))&D::d;
179 extern constexpr int (B1::*be) = (int(B1::*))&C::e;
180 extern constexpr int (B1::*b1z) = (int(B1::*))&D::z;
181 extern constexpr int (B2::*b2z) = (int(B2::*))&D::z;
182
183 // CHECK: @_ZN9MemberPtr2dfE = constant {{.*}} { i64 1, i64 0 }
184 // CHECK: @_ZN9MemberPtr2dgE = constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 }
185 // CHECK: @_ZN9MemberPtr2dhE = constant {{.*}} { i64 1, i64 24 }
186 // CHECK: @_ZN9MemberPtr2diE = constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 24 }
187 // CHECK: @_ZN9MemberPtr2djE = constant {{.*}} { i64 9, i64 0 }
188 // CHECK: @_ZN9MemberPtr2dkE = constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 }
189 // CHECK: @_ZN9MemberPtr2dlE = constant {{.*}} { i64 17, i64 0 }
190 // CHECK: @_ZN9MemberPtr2dmE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 }
191 extern constexpr void (D::*df)() = &C::f;
192 extern constexpr void (D::*dg)() = &B1::g;
193 extern constexpr void (D::*dh)() = &B2::h;
194 extern constexpr void (D::*di)() = &D::i;
195 extern constexpr void (D::*dj)() = &C::j;
196 extern constexpr void (D::*dk)() = &C::k;
197 extern constexpr void (D::*dl)() = &D::l;
198 extern constexpr void (D::*dm)() = &D::m;
199
200 // CHECK: @_ZN9MemberPtr2bfE = constant {{.*}} { i64 1, i64 0 }
201 // CHECK: @_ZN9MemberPtr2bgE = constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 }
202 // CHECK: @_ZN9MemberPtr2bhE = constant {{.*}} { i64 1, i64 0 }
203 // CHECK: @_ZN9MemberPtr2biE = constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 0 }
204 // CHECK: @_ZN9MemberPtr2bjE = constant {{.*}} { i64 9, i64 0 }
205 // CHECK: @_ZN9MemberPtr2bkE = constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 }
206 // CHECK: @_ZN9MemberPtr3b1lE = constant {{.*}} { i64 17, i64 0 }
207 // CHECK: @_ZN9MemberPtr3b1mE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 }
208 // CHECK: @_ZN9MemberPtr3b2lE = constant {{.*}} { i64 17, i64 -24 }
209 // CHECK: @_ZN9MemberPtr3b2mE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 -24 }
210 extern constexpr void (B1::*bf)() = (void(B1::*)())&C::f;
211 extern constexpr void (B1::*bg)() = (void(B1::*)())&B1::g;
212 extern constexpr void (B2::*bh)() = (void(B2::*)())&B2::h;
213 extern constexpr void (B2::*bi)() = (void(B2::*)())&D::i;
214 extern constexpr void (B1::*bj)() = (void(B1::*)())&C::j;
215 extern constexpr void (B1::*bk)() = (void(B1::*)())&C::k;
216 extern constexpr void (B1::*b1l)() = (void(B1::*)())&D::l;
217 extern constexpr void (B1::*b1m)() = (void(B1::*)())&D::m;
218 extern constexpr void (B2::*b2l)() = (void(B2::*)())&D::l;
219 extern constexpr void (B2::*b2m)() = (void(B2::*)())&D::m;
220 }
221
222 namespace LiteralReference {
223 struct Lit {
LitLiteralReference::Lit224 constexpr Lit() : n(5) {}
225 int n;
226 };
227
228 // This creates a non-const temporary and binds a reference to it.
229 // CHECK: @[[TEMP:.*]] = internal global {{.*}} { i32 5 }, align 4
230 // CHECK: @_ZN16LiteralReference3litE = constant {{.*}} @[[TEMP]], align 8
231 const Lit &lit = Lit();
232
233 // This creates a const temporary as part of the reference initialization.
234 // CHECK: @[[TEMP:.*]] = internal constant {{.*}} { i32 5 }, align 4
235 // CHECK: @_ZN16LiteralReference4lit2E = constant {{.*}} @[[TEMP]], align 8
236 const Lit &lit2 = {};
237
238 struct A { int &&r1; const int &&r2; };
239 struct B { A &&a1; const A &&a2; };
240 B b = { { 0, 1 }, { 2, 3 } };
241 // CHECK: @[[TEMP0:.*]] = internal global i32 0, align 4
242 // CHECK: @[[TEMP1:.*]] = internal constant i32 1, align 4
243 // CHECK: @[[TEMPA1:.*]] = internal global {{.*}} { i32* @[[TEMP0]], i32* @[[TEMP1]] }, align 8
244 // CHECK: @[[TEMP2:.*]] = internal global i32 2, align 4
245 // CHECK: @[[TEMP3:.*]] = internal constant i32 3, align 4
246 // CHECK: @[[TEMPA2:.*]] = internal constant {{.*}} { i32* @[[TEMP2]], i32* @[[TEMP3]] }, align 8
247 // CHECK: @_ZN16LiteralReference1bE = global {{.*}} { {{.*}}* @[[TEMPA1]], {{.*}}* @[[TEMPA2]] }, align 8
248
249 struct Subobj {
250 int a, b, c;
251 };
252 // CHECK: @[[TEMP:.*]] = internal global {{.*}} { i32 1, i32 2, i32 3 }, align 4
253 // CHECK: @_ZN16LiteralReference2soE = constant {{.*}} (i8* getelementptr {{.*}} @[[TEMP]]{{.*}}, i64 4)
254 constexpr int &&so = Subobj{ 1, 2, 3 }.b;
255
256 struct Dummy { int padding; };
257 struct Derived : Dummy, Subobj {
DerivedLiteralReference::Derived258 constexpr Derived() : Dummy{200}, Subobj{4, 5, 6} {}
259 };
260 using ConstDerived = const Derived;
261 // CHECK: @[[TEMPCOMMA:.*]] = internal constant {{.*}} { i32 200, i32 4, i32 5, i32 6 }
262 // CHECK: @_ZN16LiteralReference5commaE = constant {{.*}} getelementptr {{.*}} @[[TEMPCOMMA]]{{.*}}, i64 8)
263 constexpr const int &comma = (1, (2, ConstDerived{}).b);
264
265 // CHECK: @[[TEMPDERIVED:.*]] = internal global {{.*}} { i32 200, i32 4, i32 5, i32 6 }
266 // CHECK: @_ZN16LiteralReference4baseE = constant {{.*}} getelementptr {{.*}} @[[TEMPDERIVED]]{{.*}}, i64 4)
267 constexpr Subobj &&base = Derived{};
268
269 // CHECK: @_ZN16LiteralReference7derivedE = constant {{.*}} @[[TEMPDERIVED]]
270 constexpr Derived &derived = static_cast<Derived&>(base);
271 }
272
273 namespace NonLiteralConstexpr {
factorial(int n)274 constexpr int factorial(int n) {
275 return n ? factorial(n-1) * n : 1;
276 }
277 extern void f(int *p);
278
279 struct NonTrivialDtor {
NonTrivialDtorNonLiteralConstexpr::NonTrivialDtor280 constexpr NonTrivialDtor() : n(factorial(5)), p(&n) {}
~NonTrivialDtorNonLiteralConstexpr::NonTrivialDtor281 ~NonTrivialDtor() {
282 f(p);
283 }
284
285 int n;
286 int *p;
287 };
288 static_assert(!__is_literal(NonTrivialDtor), "");
289 // CHECK: @_ZN19NonLiteralConstexpr3ntdE = global {{.*}} { i32 120, i32* getelementptr
290 NonTrivialDtor ntd;
291
292 struct VolatileMember {
VolatileMemberNonLiteralConstexpr::VolatileMember293 constexpr VolatileMember() : n(5) {}
294 volatile int n;
295 };
296 static_assert(!__is_literal(VolatileMember), "");
297 // CHECK: @_ZN19NonLiteralConstexpr2vmE = global {{.*}} { i32 5 }
298 VolatileMember vm;
299
300 struct Both {
BothNonLiteralConstexpr::Both301 constexpr Both() : n(10) {}
302 ~Both();
303 volatile int n;
304 };
305 // CHECK: @_ZN19NonLiteralConstexpr1bE = global {{.*}} { i32 10 }
306 Both b;
307
StaticVars()308 void StaticVars() {
309 // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE3ntd = {{.*}} { i32 120, i32* getelementptr {{.*}}
310 // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE3ntd =
311 static NonTrivialDtor ntd;
312 // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE2vm = {{.*}} { i32 5 }
313 // CHECK-NOT: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE2vm =
314 static VolatileMember vm;
315 // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE1b = {{.*}} { i32 10 }
316 // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE1b =
317 static Both b;
318 }
319 }
320
321 // PR12067
322 namespace VirtualMembers {
323 struct A {
AVirtualMembers::A324 constexpr A(double d) : d(d) {}
325 virtual void f();
326 double d;
327 };
328 struct B : A {
BVirtualMembers::B329 constexpr B() : A(2.0), c{'h', 'e', 'l', 'l', 'o'} {}
BVirtualMembers::B330 constexpr B(int n) : A(n), c{'w', 'o', 'r', 'l', 'd'} {}
331 virtual void g();
332 char c[5];
333 };
334 struct C {
CVirtualMembers::C335 constexpr C() : n(64) {}
336 int n;
337 };
338 struct D : C, A, B {
DVirtualMembers::D339 constexpr D() : A(1.0), B(), s(5) {}
340 short s;
341 };
342 struct E : D, B {
EVirtualMembers::E343 constexpr E() : B(3), c{'b','y','e'} {}
344 char c[3];
345 };
346 // CHECK: @_ZN14VirtualMembers1eE = global { i8**, double, i32, i8**, double, [5 x i8], i16, i8**, double, [5 x i8], [3 x i8] } { i8** getelementptr inbounds ([11 x i8*], [11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 2), double 1.000000e+00, i32 64, i8** getelementptr inbounds ([11 x i8*], [11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 5), double 2.000000e+00, [5 x i8] c"hello", i16 5, i8** getelementptr inbounds ([11 x i8*], [11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 9), double 3.000000e+00, [5 x i8] c"world", [3 x i8] c"bye" }
347 E e;
348
349 struct nsMemoryImpl {
350 virtual void f();
351 };
352 // CHECK: @_ZN14VirtualMembersL13sGlobalMemoryE = internal global { i8** } { i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTVN14VirtualMembers12nsMemoryImplE, i64 0, i64 2) }
353 static nsMemoryImpl sGlobalMemory;
354
355 template<class T>
356 struct TemplateClass {
TemplateClassVirtualMembers::TemplateClass357 constexpr TemplateClass() : t{42} {}
templateMethodVirtualMembers::TemplateClass358 virtual void templateMethod() {}
359
360 T t;
361 };
362 // CHECK: @_ZN14VirtualMembers1tE = global { i8**, i32 } { i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTVN14VirtualMembers13TemplateClassIiEE, i64 0, i64 2), i32 42 }
363 TemplateClass<int> t;
364 }
365
366 namespace PR13273 {
367 struct U {
368 int t;
369 U() = default;
370 };
371
372 struct S : U {
373 S() = default;
374 };
375
376 // CHECK: @_ZN7PR132731sE = {{.*}} zeroinitializer
377 extern const S s {};
378 }
379
380 namespace ArrayTemporary {
381 struct A { const int (&x)[3]; };
382 struct B { const A (&x)[2]; };
383 // CHECK: @[[A1:_ZGRN14ArrayTemporary1bE.*]] = internal constant [3 x i32] [i32 1, i32 2, i32 3]
384 // CHECK: @[[A2:_ZGRN14ArrayTemporary1bE.*]] = internal constant [3 x i32] [i32 4, i32 5, i32 6]
385 // CHECK: @[[ARR:_ZGRN14ArrayTemporary1bE.*]] = internal constant [2 x {{.*}}] [{{.*}} { [3 x i32]* @[[A1]] }, {{.*}} { [3 x i32]* @[[A2]] }]
386 // CHECK: @[[B:_ZGRN14ArrayTemporary1bE.*]] = internal global {{.*}} { [2 x {{.*}}]* @[[ARR]] }
387 // CHECK: @_ZN14ArrayTemporary1bE = constant {{.*}}* @[[B]]
388 B &&b = { { { { 1, 2, 3 } }, { { 4, 5, 6 } } } };
389 }
390
391 namespace UnemittedTemporaryDecl {
392 constexpr int &&ref = 0;
393 extern constexpr int &ref2 = ref;
394 // CHECK: @_ZGRN22UnemittedTemporaryDecl3refE_ = internal global i32 0
395
396 // FIXME: This declaration should not be emitted -- it isn't odr-used.
397 // CHECK: @_ZN22UnemittedTemporaryDecl3refE
398
399 // CHECK: @_ZN22UnemittedTemporaryDecl4ref2E = constant i32* @_ZGRN22UnemittedTemporaryDecl3refE_
400 }
401
402 // CHECK: @_ZZN12LocalVarInit3aggEvE1a = internal constant {{.*}} i32 101
403 // CHECK: @_ZZN12LocalVarInit4ctorEvE1a = internal constant {{.*}} i32 102
404 // CHECK: @_ZZN12LocalVarInit8mutable_EvE1a = private unnamed_addr constant {{.*}} i32 103
405 // CHECK: @_ZGRN33ClassTemplateWithStaticDataMember1SIvE1aE_ = linkonce_odr constant i32 5, comdat
406 // CHECK: @_ZN33ClassTemplateWithStaticDataMember3useE = constant i32* @_ZGRN33ClassTemplateWithStaticDataMember1SIvE1aE_
407 // CHECK: @_ZGRN39ClassTemplateWithHiddenStaticDataMember1SIvE1aE_ = linkonce_odr hidden constant i32 5, comdat
408 // CHECK: @_ZN39ClassTemplateWithHiddenStaticDataMember3useE = constant i32* @_ZGRN39ClassTemplateWithHiddenStaticDataMember1SIvE1aE_
409 // CHECK: @_ZGRZN20InlineStaticConstRef3funEvE1i_ = linkonce_odr constant i32 10, comdat
410
411 // Constant initialization tests go before this point,
412 // dynamic initialization tests go after.
413
414 // We must emit a constant initializer for NonLiteralConstexpr::ntd, but also
415 // emit an initializer to register its destructor.
416 // CHECK: define {{.*}}cxx_global_var_init{{.*}}
417 // CHECK-NOT: NonLiteralConstexpr
418 // CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev {{.*}} @_ZN19NonLiteralConstexpr3ntdE
419 // CHECK-NEXT: ret void
420
421 // We don't need to emit any dynamic initialization for NonLiteralConstexpr::vm.
422 // CHECK-NOT: NonLiteralConstexpr2vm
423
424 // We must emit a constant initializer for NonLiteralConstexpr::b, but also
425 // emit an initializer to register its destructor.
426 // CHECK: define {{.*}}cxx_global_var_init{{.*}}
427 // CHECK-NOT: NonLiteralConstexpr
428 // CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr4BothD1Ev {{.*}} @_ZN19NonLiteralConstexpr1bE
429 // CHECK-NEXT: ret void
430
431 // CHECK: define {{.*}}NonLiteralConstexpr10StaticVars
432 // CHECK-NOT: }
433 // CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev
434 // CHECK-NOT: }
435 // CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr4BothD1Ev
436
437 // PR12848: Don't emit dynamic initializers for local constexpr variables.
438 namespace LocalVarInit {
f(int n)439 constexpr int f(int n) { return n; }
440 struct Agg { int k; };
CtorLocalVarInit::Ctor441 struct Ctor { constexpr Ctor(int n) : k(n) {} int k; };
MutableLocalVarInit::Mutable442 struct Mutable { constexpr Mutable(int n) : k(n) {} mutable int k; };
443
444 // CHECK: define {{.*}} @_ZN12LocalVarInit6scalarEv
445 // CHECK-NOT: call
446 // CHECK: store i32 100,
447 // CHECK-NOT: call
448 // CHECK: ret i32 100
scalar()449 int scalar() { constexpr int a = { f(100) }; return a; }
450
451 // CHECK: define {{.*}} @_ZN12LocalVarInit3aggEv
452 // CHECK-NOT: call
453 // CHECK: ret i32 101
agg()454 int agg() { constexpr Agg a = { f(101) }; return a.k; }
455
456 // CHECK: define {{.*}} @_ZN12LocalVarInit4ctorEv
457 // CHECK-NOT: call
458 // CHECK: ret i32 102
ctor()459 int ctor() { constexpr Ctor a = { f(102) }; return a.k; }
460
461 // CHECK: define {{.*}} @_ZN12LocalVarInit8mutable_Ev
462 // CHECK-NOT: call
463 // CHECK: call {{.*}}memcpy{{.*}} @_ZZN12LocalVarInit8mutable_EvE1a
464 // CHECK-NOT: call
465 // Can't fold return value due to 'mutable'.
466 // CHECK-NOT: ret i32 103
467 // CHECK: }
mutable_()468 int mutable_() { constexpr Mutable a = { f(103) }; return a.k; }
469 }
470
471 namespace CrossFuncLabelDiff {
472 // Make sure we refuse to constant-fold the variable b.
a(bool x)473 constexpr long a(bool x) { return x ? 0 : (long)&&lbl + (0 && ({lbl: 0;})); }
test()474 void test() { static long b = (long)&&lbl - a(false); lbl: return; }
475 // CHECK: sub nsw i64 ptrtoint (i8* blockaddress(@_ZN18CrossFuncLabelDiff4testEv, {{.*}}) to i64),
476 // CHECK: store i64 {{.*}}, i64* @_ZZN18CrossFuncLabelDiff4testEvE1b, align 8
477 }
478
479 // PR12012
480 namespace VirtualBase {
481 struct B {};
482 struct D : virtual B {};
483 D d;
484 // CHECK: call {{.*}}@_ZN11VirtualBase1DC1Ev
485
486 template<typename T> struct X : T {
XVirtualBase::X487 constexpr X() : T() {}
488 };
489 X<D> x;
490 // CHECK: call {{.*}}@_ZN11VirtualBase1XINS_1DEEC1Ev
491 }
492
493 // PR12145
494 namespace Unreferenced {
495 int n;
496 constexpr int *p = &n;
497 // We must not emit a load of 'p' here, since it's not odr-used.
498 int q = *p;
499 // CHECK-NOT: _ZN12Unreferenced1pE
500 // CHECK: = load i32, i32* @_ZN12Unreferenced1nE
501 // CHECK-NEXT: store i32 {{.*}}, i32* @_ZN12Unreferenced1qE
502 // CHECK-NOT: _ZN12Unreferenced1pE
503
504 // Technically, we are not required to substitute variables of reference types
505 // initialized by constant expressions, because the special case for odr-use
506 // of variables in [basic.def.odr]p2 only applies to objects. But we do so
507 // anyway.
508
509 constexpr int &r = n;
510 // CHECK-NOT: _ZN12Unreferenced1rE
511 int s = r;
512
513 const int t = 1;
514 const int &rt = t;
515 int f(int);
516 int u = f(rt);
517 // CHECK: call i32 @_ZN12Unreferenced1fEi(i32 1)
518 }
519
520 namespace InitFromConst {
521 template<typename T> void consume(T);
522
523 const bool b = true;
524 const int n = 5;
525 constexpr double d = 4.3;
526
527 struct S { int n = 7; S *p = 0; };
528 constexpr S s = S();
529 const S &r = s;
530 constexpr const S *p = &r;
531 constexpr int S::*mp = &S::n;
532 constexpr int a[3] = { 1, 4, 9 };
533
test()534 void test() {
535 // CHECK: call void @_ZN13InitFromConst7consumeIbEEvT_(i1 zeroext true)
536 consume(b);
537
538 // CHECK: call void @_ZN13InitFromConst7consumeIiEEvT_(i32 5)
539 consume(n);
540
541 // CHECK: call void @_ZN13InitFromConst7consumeIdEEvT_(double 4.300000e+00)
542 consume(d);
543
544 // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* dereferenceable({{[0-9]+}}) @_ZN13InitFromConstL1sE)
545 consume<const S&>(s);
546
547 // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* dereferenceable({{[0-9]+}}) @_ZN13InitFromConstL1sE)
548 consume<const S&>(r);
549
550 // CHECK: call void @_ZN13InitFromConst7consumeIPKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE)
551 consume(p);
552
553 // CHECK: call void @_ZN13InitFromConst7consumeIMNS_1SEiEEvT_(i64 0)
554 consume(mp);
555
556 // CHECK: call void @_ZN13InitFromConst7consumeIPKiEEvT_(i32* getelementptr inbounds ([3 x i32], [3 x i32]* @_ZN13InitFromConstL1aE, i32 0, i32 0))
557 consume(a);
558 }
559 }
560
561 namespace Null {
562 decltype(nullptr) null();
563 // CHECK: call {{.*}} @_ZN4Null4nullEv(
564 int *p = null();
565 struct S {};
566 // CHECK: call {{.*}} @_ZN4Null4nullEv(
567 int S::*q = null();
568 }
569
570 namespace InlineStaticConstRef {
fun()571 inline const int &fun() {
572 static const int &i = 10;
573 return i;
574 // CHECK: ret i32* @_ZGRZN20InlineStaticConstRef3funEvE1i_
575 }
576 const int &use = fun();
577 }
578
579 namespace ClassTemplateWithStaticDataMember {
580 template <typename T>
581 struct S {
582 static const int &a;
583 };
584 template <typename T>
585 const int &S<T>::a = 5;
586 const int &use = S<void>::a;
587 }
588
589 namespace ClassTemplateWithHiddenStaticDataMember {
590 template <typename T>
591 struct S {
592 __attribute__((visibility("hidden"))) static const int &a;
593 };
594 template <typename T>
595 const int &S<T>::a = 5;
596 const int &use = S<void>::a;
597 }
598
599 namespace ClassWithStaticConstexprDataMember {
600 struct X {
601 static constexpr const char &p = 'c';
602 };
603
604 // CHECK: @_ZGRN34ClassWithStaticConstexprDataMember1X1pE_
f()605 const char *f() { return &X::p; }
606 }
607
608 // VirtualMembers::TemplateClass::templateMethod() must be defined in this TU,
609 // not just declared.
610 // CHECK: define linkonce_odr void @_ZN14VirtualMembers13TemplateClassIiE14templateMethodEv(%"struct.VirtualMembers::TemplateClass"* %this)
611