1// RUN: not %clang_cc1 -verify -triple x86_64-apple-darwin -emit-llvm -o - %s -std=c++11 | FileCheck %s
2
3// FIXME: The padding in all these objects should be zero-initialized.
4namespace StructUnion {
5  struct A {
6    int n;
7    double d;
8    union U {
9      constexpr U(int x) : x(x) {}
10      constexpr U(const char *y) : y(y) {}
11      int x;
12      const char *y;
13    } u;
14
15    constexpr A(int n, double d, int x) : n(n), d(d), u(x) {}
16    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]* @{{.*}}, 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 {
38    constexpr C() : c(0) {}
39    int c;
40  };
41
42  // CHECK: @_ZN11StructUnion1eE = global {{.*}} zeroinitializer
43  C e[10];
44
45  struct D {
46    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
65namespace 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>
73  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; };
94  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
99namespace 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
109  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];
120    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
126  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
133namespace 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
222namespace LiteralReference {
223  struct Lit {
224    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:.*]] = private 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:.*]] = private 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:.*]] = private global i32 0, align 4
242  // CHECK: @[[TEMP1:.*]] = private constant i32 1, align 4
243  // CHECK: @[[TEMPA1:.*]] = private global {{.*}} { i32* @[[TEMP0]], i32* @[[TEMP1]] }, align 8
244  // CHECK: @[[TEMP2:.*]] = private global i32 2, align 4
245  // CHECK: @[[TEMP3:.*]] = private constant i32 3, align 4
246  // CHECK: @[[TEMPA2:.*]] = private 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:.*]] = private 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 {
258    constexpr Derived() : Dummy{200}, Subobj{4, 5, 6} {}
259  };
260  using ConstDerived = const Derived;
261  // CHECK: @[[TEMPCOMMA:.*]] = private 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:.*]] = private 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
273namespace NonLiteralConstexpr {
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 {
280    constexpr NonTrivialDtor() : n(factorial(5)), p(&n) {}
281    ~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 {
293    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 {
301    constexpr Both() : n(10) {}
302    ~Both();
303    volatile int n;
304  };
305  // CHECK: @_ZN19NonLiteralConstexpr1bE = global {{.*}} { i32 10 }
306  Both b;
307
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
322namespace VirtualMembers {
323  struct A {
324    constexpr A(double d) : d(d) {}
325    virtual void f();
326    double d;
327  };
328  struct B : A {
329    constexpr B() : A(2.0), c{'h', 'e', 'l', 'l', 'o'} {}
330    constexpr B(int n) : A(n), c{'w', 'o', 'r', 'l', 'd'} {}
331    virtual void g();
332    char c[5];
333  };
334  struct C {
335    constexpr C() : n(64) {}
336    int n;
337  };
338  struct D : C, A, B {
339    constexpr D() : A(1.0), B(), s(5) {}
340    short s;
341  };
342  struct E : D, B {
343    constexpr E() : B(3), c{'b','y','e'} {}
344    char c[3];
345  };
346
347  // 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*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 2), double 1.000000e+00, i32 64, i8** getelementptr inbounds ([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*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 9), double 3.000000e+00, [5 x i8] c"world", [3 x i8] c"bye" }
348  E e;
349
350  struct nsMemoryImpl {
351    virtual void f();
352  };
353  // CHECK: @_ZN14VirtualMembersL13sGlobalMemoryE = internal global { i8** } { i8** getelementptr inbounds ([3 x i8*]* @_ZTVN14VirtualMembers12nsMemoryImplE, i64 0, i64 2) }
354  static nsMemoryImpl sGlobalMemory;
355}
356
357namespace PR13273 {
358  struct U {
359    int t;
360    U() = default;
361  };
362
363  struct S : U {
364    S() = default;
365  };
366
367  // CHECK: @_ZN7PR132731sE = {{.*}} zeroinitializer
368  extern const S s {};
369}
370
371namespace ArrayTemporary {
372  struct A { const int (&x)[3]; };
373  struct B { const A (&x)[2]; };
374  // CHECK: @[[A1:_ZGRN14ArrayTemporary1bE.*]] = private constant [3 x i32] [i32 1, i32 2, i32 3]
375  // CHECK: @[[A2:_ZGRN14ArrayTemporary1bE.*]] = private constant [3 x i32] [i32 4, i32 5, i32 6]
376  // CHECK: @[[ARR:_ZGRN14ArrayTemporary1bE.*]] = private constant [2 x {{.*}}] [{{.*}} { [3 x i32]* @[[A1]] }, {{.*}} { [3 x i32]* @[[A2]] }]
377  // CHECK: @[[B:_ZGRN14ArrayTemporary1bE.*]] = private global {{.*}} { [2 x {{.*}}]* @[[ARR]] }
378  // CHECK: @_ZN14ArrayTemporary1bE = constant {{.*}}* @[[B]]
379  B &&b = { { { { 1, 2, 3 } }, { { 4, 5, 6 } } } };
380}
381
382namespace UnemittedTemporaryDecl {
383  constexpr int &&ref = 0;
384  extern constexpr int &ref2 = ref;
385  // CHECK: @_ZGRN22UnemittedTemporaryDecl3refE_ = private global i32 0
386
387  // FIXME: This declaration should not be emitted -- it isn't odr-used.
388  // CHECK: @_ZN22UnemittedTemporaryDecl3refE
389
390  // CHECK: @_ZN22UnemittedTemporaryDecl4ref2E = constant i32* @_ZGRN22UnemittedTemporaryDecl3refE_
391}
392
393// CHECK: @_ZZN12LocalVarInit3aggEvE1a = internal constant {{.*}} i32 101
394// CHECK: @_ZZN12LocalVarInit4ctorEvE1a = internal constant {{.*}} i32 102
395// CHECK: @_ZZN12LocalVarInit8mutable_EvE1a = private unnamed_addr constant {{.*}} i32 103
396// CHECK: @_ZGRN33ClassTemplateWithStaticDataMember1SIvE1aE_ = linkonce_odr constant i32 5
397// CHECK: @_ZN33ClassTemplateWithStaticDataMember3useE = constant i32* @_ZGRN33ClassTemplateWithStaticDataMember1SIvE1aE_
398// CHECK: @_ZGRN39ClassTemplateWithHiddenStaticDataMember1SIvE1aE_ = linkonce_odr hidden constant i32 5
399// CHECK: @_ZN39ClassTemplateWithHiddenStaticDataMember3useE = constant i32* @_ZGRN39ClassTemplateWithHiddenStaticDataMember1SIvE1aE_
400// CHECK: @_ZGRZN20InlineStaticConstRef3funEvE1i_ = linkonce_odr constant i32 10
401
402// Constant initialization tests go before this point,
403// dynamic initialization tests go after.
404
405// We must emit a constant initializer for NonLiteralConstexpr::ntd, but also
406// emit an initializer to register its destructor.
407// CHECK: define {{.*}}cxx_global_var_init{{.*}}
408// CHECK-NOT: NonLiteralConstexpr
409// CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev {{.*}} @_ZN19NonLiteralConstexpr3ntdE
410// CHECK-NEXT: ret void
411
412// We don't need to emit any dynamic initialization for NonLiteralConstexpr::vm.
413// CHECK-NOT: NonLiteralConstexpr2vm
414
415// We must emit a constant initializer for NonLiteralConstexpr::b, but also
416// emit an initializer to register its destructor.
417// CHECK: define {{.*}}cxx_global_var_init{{.*}}
418// CHECK-NOT: NonLiteralConstexpr
419// CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr4BothD1Ev {{.*}} @_ZN19NonLiteralConstexpr1bE
420// CHECK-NEXT: ret void
421
422// CHECK: define {{.*}}NonLiteralConstexpr10StaticVars
423// CHECK-NOT: }
424// CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev
425// CHECK-NOT: }
426// CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr4BothD1Ev
427
428// PR12848: Don't emit dynamic initializers for local constexpr variables.
429namespace LocalVarInit {
430  constexpr int f(int n) { return n; }
431  struct Agg { int k; };
432  struct Ctor { constexpr Ctor(int n) : k(n) {} int k; };
433  struct Mutable { constexpr Mutable(int n) : k(n) {} mutable int k; };
434
435  // CHECK: define {{.*}} @_ZN12LocalVarInit6scalarEv
436  // CHECK-NOT: call
437  // CHECK: store i32 100,
438  // CHECK-NOT: call
439  // CHECK: ret i32 100
440  int scalar() { constexpr int a = { f(100) }; return a; }
441
442  // CHECK: define {{.*}} @_ZN12LocalVarInit3aggEv
443  // CHECK-NOT: call
444  // CHECK: ret i32 101
445  int agg() { constexpr Agg a = { f(101) }; return a.k; }
446
447  // CHECK: define {{.*}} @_ZN12LocalVarInit4ctorEv
448  // CHECK-NOT: call
449  // CHECK: ret i32 102
450  int ctor() { constexpr Ctor a = { f(102) }; return a.k; }
451
452  // CHECK: define {{.*}} @_ZN12LocalVarInit8mutable_Ev
453  // CHECK-NOT: call
454  // CHECK: call {{.*}}memcpy{{.*}} @_ZZN12LocalVarInit8mutable_EvE1a
455  // CHECK-NOT: call
456  // Can't fold return value due to 'mutable'.
457  // CHECK-NOT: ret i32 103
458  // CHECK: }
459  int mutable_() { constexpr Mutable a = { f(103) }; return a.k; }
460}
461
462namespace CrossFuncLabelDiff {
463  // Make sure we refuse to constant-fold the variable b.
464  constexpr long a(bool x) { return x ? 0 : (long)&&lbl + (0 && ({lbl: 0;})); }
465  void test() { static long b = (long)&&lbl - a(false); lbl: return; }
466  // CHECK: sub nsw i64 ptrtoint (i8* blockaddress(@_ZN18CrossFuncLabelDiff4testEv, {{.*}}) to i64),
467  // CHECK: store i64 {{.*}}, i64* @_ZZN18CrossFuncLabelDiff4testEvE1b, align 8
468}
469
470// PR12012
471namespace VirtualBase {
472  struct B {};
473  struct D : virtual B {};
474  D d;
475  // CHECK: call {{.*}}@_ZN11VirtualBase1DC1Ev
476
477  template<typename T> struct X : T {
478    constexpr X() : T() {}
479  };
480  X<D> x;
481  // CHECK: call {{.*}}@_ZN11VirtualBase1XINS_1DEEC1Ev
482}
483
484// PR12145
485namespace Unreferenced {
486  int n;
487  constexpr int *p = &n;
488  // We must not emit a load of 'p' here, since it's not odr-used.
489  int q = *p;
490  // CHECK-NOT: _ZN12Unreferenced1pE
491  // CHECK: = load i32* @_ZN12Unreferenced1nE
492  // CHECK-NEXT: store i32 {{.*}}, i32* @_ZN12Unreferenced1qE
493  // CHECK-NOT: _ZN12Unreferenced1pE
494
495  // Technically, we are not required to substitute variables of reference types
496  // initialized by constant expressions, because the special case for odr-use
497  // of variables in [basic.def.odr]p2 only applies to objects. But we do so
498  // anyway.
499
500  constexpr int &r = n;
501  // CHECK-NOT: _ZN12Unreferenced1rE
502  int s = r;
503
504  const int t = 1;
505  const int &rt = t;
506  int f(int);
507  int u = f(rt);
508  // CHECK: call i32 @_ZN12Unreferenced1fEi(i32 1)
509}
510
511namespace InitFromConst {
512  template<typename T> void consume(T);
513
514  const bool b = true;
515  const int n = 5;
516  constexpr double d = 4.3;
517
518  struct S { int n = 7; S *p = 0; };
519  constexpr S s = S();
520  const S &r = s;
521  constexpr const S *p = &r;
522  constexpr int S::*mp = &S::n;
523  constexpr int a[3] = { 1, 4, 9 };
524
525  void test() {
526    // CHECK: call void @_ZN13InitFromConst7consumeIbEEvT_(i1 zeroext true)
527    consume(b);
528
529    // CHECK: call void @_ZN13InitFromConst7consumeIiEEvT_(i32 5)
530    consume(n);
531
532    // CHECK: call void @_ZN13InitFromConst7consumeIdEEvT_(double 4.300000e+00)
533    consume(d);
534
535    // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* nonnull @_ZN13InitFromConstL1sE)
536    consume<const S&>(s);
537
538    // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* nonnull @_ZN13InitFromConstL1sE)
539    consume<const S&>(r);
540
541    // CHECK: call void @_ZN13InitFromConst7consumeIPKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE)
542    consume(p);
543
544    // CHECK: call void @_ZN13InitFromConst7consumeIMNS_1SEiEEvT_(i64 0)
545    consume(mp);
546
547    // CHECK: call void @_ZN13InitFromConst7consumeIPKiEEvT_(i32* getelementptr inbounds ([3 x i32]* @_ZN13InitFromConstL1aE, i32 0, i32 0))
548    consume(a);
549  }
550}
551
552namespace Null {
553  decltype(nullptr) null();
554  // CHECK: call {{.*}} @_ZN4Null4nullEv(
555  int *p = null();
556  struct S {};
557  // CHECK: call {{.*}} @_ZN4Null4nullEv(
558  int S::*q = null();
559}
560
561namespace InlineStaticConstRef {
562  inline const int &fun() {
563    static const int &i = 10;
564    return i;
565    // CHECK: ret i32* @_ZGRZN20InlineStaticConstRef3funEvE1i_
566  }
567  const int &use = fun();
568}
569
570namespace ClassTemplateWithStaticDataMember {
571  template <typename T>
572  struct S {
573    static const int &a;
574  };
575  template <typename T>
576  const int &S<T>::a = 5;
577  const int &use = S<void>::a;
578}
579
580namespace ClassTemplateWithHiddenStaticDataMember {
581  template <typename T>
582  struct S {
583    __attribute__((visibility("hidden"))) static const int &a;
584  };
585  template <typename T>
586  const int &S<T>::a = 5;
587  const int &use = S<void>::a;
588}
589