1 // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -std=c++11 | FileCheck %s -check-prefixes=CHECK,NULL-INVALID,CHECK-CXX11
2 // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -std=c++17 | FileCheck %s -check-prefixes=CHECK,NULL-INVALID,CHECK-CXX17
3 // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -std=c++11 -fno-delete-null-pointer-checks | FileCheck %s -check-prefixes=CHECK,NULL-VALID,CHECK-CXX11
4 
5 namespace PR16263 {
6   const unsigned int n = 1234;
7   extern const int &r = (const int&)n;
8   // CHECK: @_ZGRN7PR162631rE_ = internal constant i32 1234,
9   // CHECK: @_ZN7PR162631rE ={{.*}} constant i32* @_ZGRN7PR162631rE_,
10 
11   extern const int &s = reinterpret_cast<const int&>(n);
12   // CHECK: @_ZN7PR16263L1nE = internal constant i32 1234, align 4
13   // CHECK: @_ZN7PR162631sE ={{.*}} constant i32* @_ZN7PR16263L1nE, align 8
14 
15   struct A { int n; };
16   struct B { int n; };
17   struct C : A, B {};
18   extern const A &&a = (A&&)(A&&)(C&&)(C{});
19   // CHECK: @_ZGRN7PR162631aE_ = internal global {{.*}} zeroinitializer,
20   // CHECK: @_ZN7PR162631aE ={{.*}} constant {{.*}} bitcast ({{.*}}* @_ZGRN7PR162631aE_ to
21 
22   extern const int &&t = ((B&&)C{}).n;
23   // CHECK: @_ZGRN7PR162631tE_ = internal global {{.*}} zeroinitializer,
24   // CHECK: @_ZN7PR162631tE ={{.*}} constant i32* {{.*}}* @_ZGRN7PR162631tE_ {{.*}} 4
25 
26   struct D { double d; C c; };
27   extern const int &&u = (123, static_cast<B&&>(0, ((D&&)D{}).*&D::c).n);
28   // CHECK: @_ZGRN7PR162631uE_ = internal global {{.*}} zeroinitializer
29   // CHECK: @_ZN7PR162631uE ={{.*}} constant i32* {{.*}} @_ZGRN7PR162631uE_ {{.*}} 12
30 }
31 
32 namespace PR20227 {
33   struct A { ~A(); };
34   struct B { virtual ~B(); };
35   struct C : B {};
36 
37   A &&a = dynamic_cast<A&&>(A{});
38   // CHECK: @_ZGRN7PR202271aE_ = internal global
39 
40   B &&b = dynamic_cast<C&&>(dynamic_cast<B&&>(C{}));
41   // CHECK: @_ZGRN7PR202271bE_ = internal global
42 
43   B &&c = static_cast<C&&>(static_cast<B&&>(C{}));
44   // CHECK: @_ZGRN7PR202271cE_ = internal global
45 }
46 
47 namespace BraceInit {
48   typedef const int &CIR;
49   CIR x = CIR{3};
50   // CHECK-CXX11: @_ZGRN9BraceInit1xE_ = internal constant i32 3
51   // FIXME: This should still be emitted as 'constant' in C++17.
52   // CHECK-CXX17: @_ZGRN9BraceInit1xE_ = internal global i32 3
53   // CHECK: @_ZN9BraceInit1xE ={{.*}} constant i32* @_ZGRN9BraceInit1xE_
54 }
55 
56 namespace RefTempSubobject {
57   struct SelfReferential {
58     int *p = ints;
59     int ints[3] = {1, 2, 3};
60   };
61 
62   // CHECK: @_ZGRN16RefTempSubobject2srE_ = internal global { i32*, [3 x i32] } { {{.*}} getelementptr {{.*}} @_ZGRN16RefTempSubobject2srE_ {{.*}}, [3 x i32] [i32 1, i32 2, i32 3] }
63   // CHECK: @_ZN16RefTempSubobject2srE = constant {{.*}} @_ZGRN16RefTempSubobject2srE_
64   constexpr const SelfReferential &sr = SelfReferential();
65 }
66 
67 struct A {
68   A();
69   ~A();
70   void f();
71 };
72 
73 void f1() {
74   // CHECK: call void @_ZN1AC1Ev
75   // CHECK: call void @_ZN1AD1Ev
76   (void)A();
77 
78   // CHECK: call void @_ZN1AC1Ev
79   // CHECK: call void @_ZN1AD1Ev
80   A().f();
81 }
82 
83 // Function calls
84 struct B {
85   B();
86   ~B();
87 };
88 
89 B g();
90 
91 void f2() {
92   // CHECK-NOT: call void @_ZN1BC1Ev
93   // CHECK: call void @_ZN1BD1Ev
94   (void)g();
95 }
96 
97 // Member function calls
98 struct C {
99   C();
100   ~C();
101 
102   C f();
103 };
104 
105 void f3() {
106   // CHECK: call void @_ZN1CC1Ev
107   // CHECK: call void @_ZN1CD1Ev
108   // CHECK: call void @_ZN1CD1Ev
109   C().f();
110 }
111 
112 // Function call operator
113 struct D {
114   D();
115   ~D();
116 
117   D operator()();
118 };
119 
120 void f4() {
121   // CHECK: call void @_ZN1DC1Ev
122   // CHECK: call void @_ZN1DD1Ev
123   // CHECK: call void @_ZN1DD1Ev
124   D()();
125 }
126 
127 // Overloaded operators
128 struct E {
129   E();
130   ~E();
131   E operator+(const E&);
132   E operator!();
133 };
134 
135 void f5() {
136   // CHECK: call void @_ZN1EC1Ev
137   // CHECK: call void @_ZN1EC1Ev
138   // CHECK: call void @_ZN1ED1Ev
139   // CHECK: call void @_ZN1ED1Ev
140   // CHECK: call void @_ZN1ED1Ev
141   E() + E();
142 
143   // CHECK: call void @_ZN1EC1Ev
144   // CHECK: call void @_ZN1ED1Ev
145   // CHECK: call void @_ZN1ED1Ev
146   !E();
147 }
148 
149 struct F {
150   F();
151   ~F();
152   F& f();
153 };
154 
155 void f6() {
156   // CHECK: call void @_ZN1FC1Ev
157   // CHECK: call void @_ZN1FD1Ev
158   F().f();
159 }
160 
161 struct G {
162   G();
163   G(A);
164   ~G();
165   operator A();
166 };
167 
168 void a(const A&);
169 
170 void f7() {
171   // CHECK: call void @_ZN1AC1Ev
172   // CHECK: call void @_Z1aRK1A
173   // CHECK: call void @_ZN1AD1Ev
174   a(A());
175 
176   // CHECK: call void @_ZN1GC1Ev
177   // CHECK: call void @_ZN1Gcv1AEv
178   // CHECK: call void @_Z1aRK1A
179   // CHECK: call void @_ZN1AD1Ev
180   // CHECK: call void @_ZN1GD1Ev
181   a(G());
182 }
183 
184 namespace PR5077 {
185 
186 struct A {
187   A();
188   ~A();
189   int f();
190 };
191 
192 void f();
193 int g(const A&);
194 
195 struct B {
196   int a1;
197   int a2;
198   B();
199   ~B();
200 };
201 
202 B::B()
203   // CHECK: call void @_ZN6PR50771AC1Ev
204   // CHECK: call i32 @_ZN6PR50771A1fEv
205   // CHECK: call void @_ZN6PR50771AD1Ev
206   : a1(A().f())
207   // CHECK: call void @_ZN6PR50771AC1Ev
208   // CHECK: call i32 @_ZN6PR50771gERKNS_1AE
209   // CHECK: call void @_ZN6PR50771AD1Ev
210   , a2(g(A()))
211 {
212   // CHECK: call void @_ZN6PR50771fEv
213   f();
214 }
215 
216 }
217 
218 A f8() {
219   // CHECK: call void @_ZN1AC1Ev
220   // CHECK-NOT: call void @_ZN1AD1Ev
221   return A();
222   // CHECK: ret void
223 }
224 
225 struct H {
226   H();
227   ~H();
228   H(const H&);
229 };
230 
231 void f9(H h) {
232   // CHECK: call void @_ZN1HC1Ev
233   // CHECK: call void @_Z2f91H
234   // CHECK: call void @_ZN1HD1Ev
235   f9(H());
236 
237   // CHECK: call void @_ZN1HC1ERKS_
238   // CHECK: call void @_Z2f91H
239   // CHECK: call void @_ZN1HD1Ev
240   f9(h);
241 }
242 
243 void f10(const H&);
244 
245 void f11(H h) {
246   // CHECK: call void @_ZN1HC1Ev
247   // CHECK: call void @_Z3f10RK1H
248   // CHECK: call void @_ZN1HD1Ev
249   f10(H());
250 
251   // CHECK: call void @_Z3f10RK1H
252   // CHECK-NOT: call void @_ZN1HD1Ev
253   // CHECK: ret void
254   f10(h);
255 }
256 
257 // PR5808
258 struct I {
259   I(const char *);
260   ~I();
261 };
262 
263 // CHECK: _Z3f12v
264 I f12() {
265   // CHECK: call void @_ZN1IC1EPKc
266   // CHECK-NOT: call void @_ZN1ID1Ev
267   // CHECK: ret void
268   return "Hello";
269 }
270 
271 // PR5867
272 namespace PR5867 {
273   struct S {
274     S();
275     S(const S &);
276     ~S();
277   };
278 
279   void f(S, int);
280   // CHECK-LABEL: define{{.*}} void @_ZN6PR58671gEv
281   void g() {
282     // CHECK: call void @_ZN6PR58671SC1Ev
283     // CHECK-NEXT: call void @_ZN6PR58671fENS_1SEi
284     // CHECK-NEXT: call void @_ZN6PR58671SD1Ev
285     // CHECK-NEXT: ret void
286     (f)(S(), 0);
287   }
288 
289   // CHECK-LABEL: define linkonce_odr void @_ZN6PR58672g2IiEEvT_
290   template<typename T>
291   void g2(T) {
292     // CHECK: call void @_ZN6PR58671SC1Ev
293     // CHECK-NEXT: call void @_ZN6PR58671fENS_1SEi
294     // CHECK-NEXT: call void @_ZN6PR58671SD1Ev
295     // CHECK-NEXT: ret void
296     (f)(S(), 0);
297   }
298 
299   void h() {
300     g2(17);
301   }
302 }
303 
304 // PR6199
305 namespace PR6199 {
306   struct A { ~A(); };
307 
308   struct B { operator A(); };
309 
310   // CHECK-LABEL: define weak_odr void @_ZN6PR61992f2IiEENS_1AET_
311   template<typename T> A f2(T) {
312     B b;
313     // CHECK: call void @_ZN6PR61991BcvNS_1AEEv
314     // CHECK-NEXT: ret void
315     return b;
316   }
317 
318   template A f2<int>(int);
319 
320 }
321 
322 namespace T12 {
323 
324 struct A {
325   A();
326   ~A();
327   int f();
328 };
329 
330 int& f(int);
331 
332 // CHECK-LABEL: define{{.*}} void @_ZN3T121gEv
333 void g() {
334   // CHECK: call void @_ZN3T121AC1Ev
335   // CHECK-NEXT: call i32 @_ZN3T121A1fEv(
336   // CHECK-NEXT: call {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) i32* @_ZN3T121fEi(
337   // CHECK-NEXT: call void @_ZN3T121AD1Ev(
338   int& i = f(A().f());
339 }
340 
341 }
342 
343 namespace PR6648 {
344   struct B {
345     ~B();
346   };
347   B foo;
348   struct D;
349   D& zed(B);
350   void foobar() {
351     // NULL-INVALID: call nonnull align 1 %"struct.PR6648::D"* @_ZN6PR66483zedENS_1BE
352     // NULL-VALID: call align 1 %"struct.PR6648::D"* @_ZN6PR66483zedENS_1BE
353     zed(foo);
354   }
355 }
356 
357 namespace UserConvertToValue {
358   struct X {
359     X(int);
360     X(const X&);
361     ~X();
362   };
363 
364   void f(X);
365 
366   // CHECK: void @_ZN18UserConvertToValue1gEv()
367   void g() {
368     // CHECK: call void @_ZN18UserConvertToValue1XC1Ei
369     // CHECK: call void @_ZN18UserConvertToValue1fENS_1XE
370     // CHECK: call void @_ZN18UserConvertToValue1XD1Ev
371     // CHECK: ret void
372     f(1);
373   }
374 }
375 
376 namespace PR7556 {
377   struct A { ~A(); };
378   struct B { int i; ~B(); };
379   struct C { int C::*pm; ~C(); };
380   // CHECK-LABEL: define{{.*}} void @_ZN6PR75563fooEv()
381   void foo() {
382     // CHECK: call void @_ZN6PR75561AD1Ev
383     A();
384     // CHECK: call void @llvm.memset.p0i8.i64
385     // CHECK: call void @_ZN6PR75561BD1Ev
386     B();
387     // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64
388     // CHECK: call void @_ZN6PR75561CD1Ev
389     C();
390     // CHECK-NEXT: ret void
391   }
392 }
393 
394 namespace Elision {
395   struct A {
396     A(); A(const A &); ~A();
397     void *p;
398     void foo() const;
399   };
400 
401   void foo();
402   A fooA();
403   void takeA(A a);
404 
405   // CHECK-LABEL: define{{.*}} void @_ZN7Elision5test0Ev()
406   void test0() {
407     // CHECK:      [[I:%.*]] = alloca [[A:%.*]], align 8
408     // CHECK-NEXT: [[J:%.*]] = alloca [[A]], align 8
409     // CHECK-NEXT: [[T0:%.*]] = alloca [[A]], align 8
410     // CHECK-NEXT: [[K:%.*]] = alloca [[A]], align 8
411     // CHECK-NEXT: [[T1:%.*]] = alloca [[A]], align 8
412 
413     // CHECK-NEXT: call void @_ZN7Elision3fooEv()
414     // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[I]])
415     A i = (foo(), A());
416 
417     // CHECK-NEXT: call void @_ZN7Elision4fooAEv([[A]]* sret([[A]]) align 8 [[T0]])
418     // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[J]])
419     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[T0]])
420     A j = (fooA(), A());
421 
422     // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[T1]])
423     // CHECK-NEXT: call void @_ZN7Elision4fooAEv([[A]]* sret([[A]]) align 8 [[K]])
424     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[T1]])
425     A k = (A(), fooA());
426 
427     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[K]])
428     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[J]])
429     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[I]])
430   }
431 
432 
433   // CHECK-LABEL: define{{.*}} void @_ZN7Elision5test1EbNS_1AE(
434   void test1(bool c, A x) {
435     // CHECK:      [[I:%.*]] = alloca [[A]], align 8
436     // CHECK-NEXT: [[J:%.*]] = alloca [[A]], align 8
437 
438     // CHECK:      call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[I]])
439     // CHECK:      call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[I]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[X:%.*]])
440     A i = (c ? A() : x);
441 
442     // CHECK:      call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[J]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[X]])
443     // CHECK:      call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[J]])
444     A j = (c ? x : A());
445 
446     // CHECK:      call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[J]])
447     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[I]])
448   }
449 
450   // CHECK: define{{.*}} void @_ZN7Elision5test2Ev([[A]]* noalias sret([[A]]) align 8
451   A test2() {
452     // CHECK:      call void @_ZN7Elision3fooEv()
453     // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[RET:%.*]])
454     // CHECK-NEXT: ret void
455     return (foo(), A());
456   }
457 
458   // CHECK: define{{.*}} void @_ZN7Elision5test3EiNS_1AE([[A]]* noalias sret([[A]]) align 8
459   A test3(int v, A x) {
460     if (v < 5)
461     // CHECK:      call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[RET:%.*]])
462     // CHECK:      call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[RET]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[X:%.*]])
463       return (v < 0 ? A() : x);
464     else
465     // CHECK:      call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[RET]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[X]])
466     // CHECK:      call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[RET]])
467       return (v > 10 ? x : A());
468 
469     // CHECK:      ret void
470   }
471 
472   // CHECK-LABEL: define{{.*}} void @_ZN7Elision5test4Ev()
473   void test4() {
474     // CHECK:      [[X:%.*]] = alloca [[A]], align 8
475     // CHECK-NEXT: [[XS:%.*]] = alloca [2 x [[A]]], align 16
476 
477     // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[X]])
478     A x;
479 
480     // CHECK-NEXT: [[XS0:%.*]] = getelementptr inbounds [2 x [[A]]], [2 x [[A]]]* [[XS]], i64 0, i64 0
481     // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* {{[^,]*}} [[XS0]])
482     // CHECK-NEXT: [[XS1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[XS0]], i64 1
483     // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[XS1]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[X]])
484     A xs[] = { A(), x };
485 
486     // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [2 x [[A]]], [2 x [[A]]]* [[XS]], i32 0, i32 0
487     // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]], [[A]]* [[BEGIN]], i64 2
488     // CHECK-NEXT: br label
489     // CHECK:      [[AFTER:%.*]] = phi [[A]]*
490     // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]], [[A]]* [[AFTER]], i64 -1
491     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[CUR]])
492     // CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[CUR]], [[BEGIN]]
493     // CHECK-NEXT: br i1 [[T0]],
494 
495     // CHECK:      call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[X]])
496   }
497 
498   // rdar://problem/8433352
499   // CHECK: define{{.*}} void @_ZN7Elision5test5Ev([[A]]* noalias sret([[A]]) align 8
500   struct B { A a; B(); };
501   A test5() {
502     // CHECK:      [[AT0:%.*]] = alloca [[A]], align 8
503     // CHECK-NEXT: [[BT0:%.*]] = alloca [[B:%.*]], align 8
504     // CHECK-NEXT: [[X:%.*]] = alloca [[A]], align 8
505     // CHECK-NEXT: [[BT1:%.*]] = alloca [[B]], align 8
506     // CHECK-NEXT: [[BT2:%.*]] = alloca [[B]], align 8
507 
508     // CHECK:      call void @_ZN7Elision1BC1Ev([[B]]* {{[^,]*}} [[BT0]])
509     // CHECK-NEXT: [[AM:%.*]] = getelementptr inbounds [[B]], [[B]]* [[BT0]], i32 0, i32 0
510     // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[AT0]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[AM]])
511     // CHECK-NEXT: call void @_ZN7Elision5takeAENS_1AE([[A]]* [[AT0]])
512     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[AT0]])
513     // CHECK-NEXT: call void @_ZN7Elision1BD1Ev([[B]]* {{[^,]*}} [[BT0]])
514     takeA(B().a);
515 
516     // CHECK-NEXT: call void @_ZN7Elision1BC1Ev([[B]]* {{[^,]*}} [[BT1]])
517     // CHECK-NEXT: [[AM:%.*]] = getelementptr inbounds [[B]], [[B]]* [[BT1]], i32 0, i32 0
518     // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[X]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[AM]])
519     // CHECK-NEXT: call void @_ZN7Elision1BD1Ev([[B]]* {{[^,]*}} [[BT1]])
520     A x = B().a;
521 
522     // CHECK-NEXT: call void @_ZN7Elision1BC1Ev([[B]]* {{[^,]*}} [[BT2]])
523     // CHECK-NEXT: [[AM:%.*]] = getelementptr inbounds [[B]], [[B]]* [[BT2]], i32 0, i32 0
524     // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* {{[^,]*}} [[RET:%.*]], [[A]]* {{(nonnull )?}}align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[AM]])
525     // CHECK-NEXT: call void @_ZN7Elision1BD1Ev([[B]]* {{[^,]*}} [[BT2]])
526     return B().a;
527 
528     // CHECK:      call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[X]])
529   }
530 
531   // Reduced from webkit.
532   // CHECK: define{{.*}} void @_ZN7Elision5test6EPKNS_1CE([[C:%.*]]*
533   struct C { operator A() const; };
534   void test6(const C *x) {
535     // CHECK:      [[T0:%.*]] = alloca [[A]], align 8
536     // CHECK:      [[X:%.*]] = load [[C]]*, [[C]]** {{%.*}}, align 8
537     // CHECK-NEXT: call void @_ZNK7Elision1CcvNS_1AEEv([[A]]* sret([[A]]) align 8 [[T0]], [[C]]* {{[^,]*}} [[X]])
538     // CHECK-NEXT: call void @_ZNK7Elision1A3fooEv([[A]]* {{[^,]*}} [[T0]])
539     // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* {{[^,]*}} [[T0]])
540     // CHECK-NEXT: ret void
541     A(*x).foo();
542   }
543 }
544 
545 namespace PR8623 {
546   struct A { A(int); ~A(); };
547 
548   // CHECK-LABEL: define{{.*}} void @_ZN6PR86233fooEb(
549   void foo(bool b) {
550     // CHECK:      [[TMP:%.*]] = alloca [[A:%.*]], align 1
551     // CHECK-NEXT: [[LCONS:%.*]] = alloca i1
552     // CHECK-NEXT: [[RCONS:%.*]] = alloca i1
553     // CHECK:      store i1 false, i1* [[LCONS]]
554     // CHECK-NEXT: store i1 false, i1* [[RCONS]]
555     // CHECK-NEXT: br i1
556     // CHECK:      call void @_ZN6PR86231AC1Ei([[A]]* {{[^,]*}} [[TMP]], i32 2)
557     // CHECK-NEXT: store i1 true, i1* [[LCONS]]
558     // CHECK-NEXT: br label
559     // CHECK:      call void @_ZN6PR86231AC1Ei([[A]]* {{[^,]*}} [[TMP]], i32 3)
560     // CHECK-NEXT: store i1 true, i1* [[RCONS]]
561     // CHECK-NEXT: br label
562     // CHECK:      load i1, i1* [[RCONS]]
563     // CHECK-NEXT: br i1
564     // CHECK:      call void @_ZN6PR86231AD1Ev([[A]]* {{[^,]*}} [[TMP]])
565     // CHECK-NEXT: br label
566     // CHECK:      load i1, i1* [[LCONS]]
567     // CHECK-NEXT: br i1
568     // CHECK:      call void @_ZN6PR86231AD1Ev([[A]]* {{[^,]*}} [[TMP]])
569     // CHECK-NEXT: br label
570     // CHECK:      ret void
571     b ? A(2) : A(3);
572   }
573 }
574 
575 namespace PR11365 {
576   struct A { A(); ~A(); };
577 
578   // CHECK-LABEL: define{{.*}} void @_ZN7PR113653fooEv(
579   void foo() {
580     // CHECK: [[BEGIN:%.*]] = getelementptr inbounds [3 x [[A:%.*]]], [3 x [[A:%.*]]]* {{.*}}, i32 0, i32 0
581     // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]], [[A]]* [[BEGIN]], i64 3
582     // CHECK-NEXT: br label
583 
584     // CHECK: [[PHI:%.*]] = phi
585     // CHECK-NEXT: [[ELEM:%.*]] = getelementptr inbounds [[A]], [[A]]* [[PHI]], i64 -1
586     // CHECK-NEXT: call void @_ZN7PR113651AD1Ev([[A]]* {{[^,]*}} [[ELEM]])
587     // CHECK-NEXT: icmp eq [[A]]* [[ELEM]], [[BEGIN]]
588     // CHECK-NEXT: br i1
589     (void) (A [3]) {};
590   }
591 }
592 
593 namespace AssignmentOp {
594   struct A { ~A(); };
595   struct B { A operator=(const B&); };
596   struct C : B { B b1, b2; };
597   // CHECK-LABEL: define{{.*}} void @_ZN12AssignmentOp1fE
598   void f(C &c1, const C &c2) {
599     // CHECK: call {{.*}} @_ZN12AssignmentOp1CaSERKS0_(
600     c1 = c2;
601   }
602 
603   // Ensure that each 'A' temporary is destroyed before the next subobject is
604   // copied.
605   // CHECK: define {{.*}} @_ZN12AssignmentOp1CaSERKS0_(
606   // CHECK: call {{.*}} @_ZN12AssignmentOp1BaSERKS
607   // CHECK: call {{.*}} @_ZN12AssignmentOp1AD1Ev(
608   // CHECK: call {{.*}} @_ZN12AssignmentOp1BaSERKS
609   // CHECK: call {{.*}} @_ZN12AssignmentOp1AD1Ev(
610   // CHECK: call {{.*}} @_ZN12AssignmentOp1BaSERKS
611   // CHECK: call {{.*}} @_ZN12AssignmentOp1AD1Ev(
612 }
613 
614 namespace BindToSubobject {
615   struct A {
616     A();
617     ~A();
618     int a;
619   };
620 
621   void f(), g();
622 
623   // CHECK: call void @_ZN15BindToSubobject1AC1Ev({{.*}} @_ZGRN15BindToSubobject1aE_)
624   // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1AD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1aE_ to i8*), i8* @__dso_handle)
625   // CHECK: store i32* getelementptr inbounds ({{.*}} @_ZGRN15BindToSubobject1aE_, i32 0, i32 0), i32** @_ZN15BindToSubobject1aE, align 8
626   int &&a = A().a;
627 
628   // CHECK: call void @_ZN15BindToSubobject1fEv()
629   // CHECK: call void @_ZN15BindToSubobject1AC1Ev({{.*}} @_ZGRN15BindToSubobject1bE_)
630   // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1AD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1bE_ to i8*), i8* @__dso_handle)
631   // CHECK: store i32* getelementptr inbounds ({{.*}} @_ZGRN15BindToSubobject1bE_, i32 0, i32 0), i32** @_ZN15BindToSubobject1bE, align 8
632   int &&b = (f(), A().a);
633 
634   int A::*h();
635 
636   // CHECK: call void @_ZN15BindToSubobject1fEv()
637   // CHECK: call void @_ZN15BindToSubobject1gEv()
638   // CHECK: call void @_ZN15BindToSubobject1AC1Ev({{.*}} @_ZGRN15BindToSubobject1cE_)
639   // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1AD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1cE_ to i8*), i8* @__dso_handle)
640   // CHECK: call {{.*}} @_ZN15BindToSubobject1hE
641   // CHECK: getelementptr
642   // CHECK: store i32* {{.*}}, i32** @_ZN15BindToSubobject1cE, align 8
643   int &&c = (f(), (g(), A().*h()));
644 
645   struct B {
646     int padding;
647     A a;
648   };
649 
650   // CHECK: call void @_ZN15BindToSubobject1BC1Ev({{.*}} @_ZGRN15BindToSubobject1dE_)
651   // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1BD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1dE_ to i8*), i8* @__dso_handle)
652   // CHECK: call {{.*}} @_ZN15BindToSubobject1hE
653   // CHECK: getelementptr {{.*}} getelementptr
654   // CHECK: store i32* {{.*}}, i32** @_ZN15BindToSubobject1dE, align 8
655   int &&d = (B().a).*h();
656 }
657 
658 namespace Bitfield {
659   struct S { int a : 5; ~S(); };
660 
661   // Do not lifetime extend the S() temporary here.
662   // CHECK: alloca
663   // CHECK: call {{.*}}memset
664   // CHECK: store i32 {{.*}}, i32* @_ZGRN8Bitfield1rE_
665   // CHECK: call void @_ZN8Bitfield1SD1
666   // CHECK: store i32* @_ZGRN8Bitfield1rE_, i32** @_ZN8Bitfield1rE, align 8
667   int &&r = S().a;
668 }
669 
670 namespace Vector {
671   typedef __attribute__((vector_size(16))) int vi4a;
672   typedef __attribute__((ext_vector_type(4))) int vi4b;
673   struct S {
674     vi4a v;
675     vi4b w;
676   };
677   // CHECK: alloca
678   // CHECK: extractelement
679   // CHECK: store i32 {{.*}}, i32* @_ZGRN6Vector1rE_
680   // CHECK: store i32* @_ZGRN6Vector1rE_, i32** @_ZN6Vector1rE,
681   int &&r = S().v[1];
682 
683   // CHECK: alloca
684   // CHECK: extractelement
685   // CHECK: store i32 {{.*}}, i32* @_ZGRN6Vector1sE_
686   // CHECK: store i32* @_ZGRN6Vector1sE_, i32** @_ZN6Vector1sE,
687   int &&s = S().w[1];
688   // FIXME PR16204: The following code leads to an assertion in Sema.
689   //int &&s = S().w.y;
690 }
691 
692 namespace ImplicitTemporaryCleanup {
693   struct A { A(int); ~A(); };
694   void g();
695 
696   // CHECK-LABEL: define{{.*}} void @_ZN24ImplicitTemporaryCleanup1fEv(
697   void f() {
698     // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1AC1Ei(
699     A &&a = 0;
700 
701     // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1gEv(
702     g();
703 
704     // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1AD1Ev(
705   }
706 }
707 
708 namespace MultipleExtension {
709   struct A { A(); ~A(); };
710   struct B { B(); ~B(); };
711   struct C { C(); ~C(); };
712   struct D { D(); ~D(); int n; C c; };
713   struct E { const A &a; B b; const C &c; ~E(); };
714 
715   E &&e1 = { A(), B(), D().c };
716 
717   // CHECK: call void @_ZN17MultipleExtension1AC1Ev({{.*}} @[[TEMPA:_ZGRN17MultipleExtension2e1E.*]])
718   // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1AD1Ev {{.*}} @[[TEMPA]]
719   // CHECK: store {{.*}} @[[TEMPA]], {{.*}} getelementptr inbounds ({{.*}} @[[TEMPE:_ZGRN17MultipleExtension2e1E.*]], i32 0, i32 0)
720 
721   // CHECK: call void @_ZN17MultipleExtension1BC1Ev({{.*}} getelementptr inbounds ({{.*}} @[[TEMPE]], i32 0, i32 1))
722 
723   // CHECK: call void @_ZN17MultipleExtension1DC1Ev({{.*}} @[[TEMPD:_ZGRN17MultipleExtension2e1E.*]])
724   // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1DD1Ev {{.*}} @[[TEMPD]]
725   // CHECK: store {{.*}} @[[TEMPD]], {{.*}} getelementptr inbounds ({{.*}} @[[TEMPE]], i32 0, i32 2)
726   // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1ED1Ev {{.*}} @[[TEMPE]]
727   // CHECK: store {{.*}} @[[TEMPE]], %"struct.MultipleExtension::E"** @_ZN17MultipleExtension2e1E, align 8
728 
729   E e2 = { A(), B(), D().c };
730 
731   // CHECK: call void @_ZN17MultipleExtension1AC1Ev({{.*}} @[[TEMPA:_ZGRN17MultipleExtension2e2E.*]])
732   // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1AD1Ev {{.*}} @[[TEMPA]]
733   // CHECK: store {{.*}} @[[TEMPA]], {{.*}} getelementptr inbounds ({{.*}} @[[E:_ZN17MultipleExtension2e2E]], i32 0, i32 0)
734 
735   // CHECK: call void @_ZN17MultipleExtension1BC1Ev({{.*}} getelementptr inbounds ({{.*}} @[[E]], i32 0, i32 1))
736 
737   // CHECK: call void @_ZN17MultipleExtension1DC1Ev({{.*}} @[[TEMPD:_ZGRN17MultipleExtension2e2E.*]])
738   // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1DD1Ev {{.*}} @[[TEMPD]]
739   // CHECK: store {{.*}} @[[TEMPD]], {{.*}} getelementptr inbounds ({{.*}} @[[E]], i32 0, i32 2)
740   // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1ED1Ev {{.*}} @[[E]]
741 
742 
743   void g();
744   // CHECK: define{{.*}} void @[[NS:_ZN17MultipleExtension]]1fEv(
745   void f() {
746     E &&e1 = { A(), B(), D().c };
747     // CHECK: %[[TEMPE1_A:.*]] = getelementptr inbounds {{.*}} %[[TEMPE1:.*]], i32 0, i32 0
748     // CHECK: call void @[[NS]]1AC1Ev({{.*}} %[[TEMPA1:.*]])
749     // CHECK: store {{.*}} %[[TEMPA1]], {{.*}} %[[TEMPE1_A]]
750     // CHECK: %[[TEMPE1_B:.*]] = getelementptr inbounds {{.*}} %[[TEMPE1]], i32 0, i32 1
751     // CHECK: call void @[[NS]]1BC1Ev({{.*}} %[[TEMPE1_B]])
752     // CHECK: %[[TEMPE1_C:.*]] = getelementptr inbounds {{.*}} %[[TEMPE1]], i32 0, i32 2
753     // CHECK: call void @[[NS]]1DC1Ev({{.*}} %[[TEMPD1:.*]])
754     // CHECK: %[[TEMPD1_C:.*]] = getelementptr inbounds {{.*}} %[[TEMPD1]], i32 0, i32 1
755     // CHECK: store {{.*}} %[[TEMPD1_C]], {{.*}} %[[TEMPE1_C]]
756     // CHECK: store {{.*}} %[[TEMPE1]], {{.*}} %[[E1:.*]]
757 
758     g();
759     // CHECK: call void @[[NS]]1gEv()
760 
761     E e2 = { A(), B(), D().c };
762     // CHECK: %[[TEMPE2_A:.*]] = getelementptr inbounds {{.*}} %[[E2:.*]], i32 0, i32 0
763     // CHECK: call void @[[NS]]1AC1Ev({{.*}} %[[TEMPA2:.*]])
764     // CHECK: store {{.*}} %[[TEMPA2]], {{.*}} %[[TEMPE2_A]]
765     // CHECK: %[[TEMPE2_B:.*]] = getelementptr inbounds {{.*}} %[[E2]], i32 0, i32 1
766     // CHECK: call void @[[NS]]1BC1Ev({{.*}} %[[TEMPE2_B]])
767     // CHECK: %[[TEMPE2_C:.*]] = getelementptr inbounds {{.*}} %[[E2]], i32 0, i32 2
768     // CHECK: call void @[[NS]]1DC1Ev({{.*}} %[[TEMPD2:.*]])
769     // CHECK: %[[TEMPD2_C:.*]] = getelementptr inbounds {{.*}} %[[TEMPD2]], i32 0, i32 1
770     // CHECK: store {{.*}} %[[TEMPD2_C]], {{.*}}* %[[TEMPE2_C]]
771 
772     g();
773     // CHECK: call void @[[NS]]1gEv()
774 
775     // CHECK: call void @[[NS]]1ED1Ev({{.*}} %[[E2]])
776     // CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD2]])
777     // CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA2]])
778     // CHECK: call void @[[NS]]1ED1Ev({{.*}} %[[TEMPE1]])
779     // CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD1]])
780     // CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA1]])
781   }
782 }
783 
784 namespace ArrayAccess {
785   struct A { A(int); ~A(); };
786   void g();
787   void f() {
788     using T = A[3];
789 
790     // CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 1
791     // CHECK-NOT: @_ZN11ArrayAccess1AD
792     // CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 2
793     // CHECK-NOT: @_ZN11ArrayAccess1AD
794     // CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 3
795     // CHECK-NOT: @_ZN11ArrayAccess1AD
796     A &&a = T{1, 2, 3}[1];
797 
798     // CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 4
799     // CHECK-NOT: @_ZN11ArrayAccess1AD
800     // CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 5
801     // CHECK-NOT: @_ZN11ArrayAccess1AD
802     // CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 6
803     // CHECK-NOT: @_ZN11ArrayAccess1AD
804     A &&b = 2[T{4, 5, 6}];
805 
806     // CHECK: call void @_ZN11ArrayAccess1gEv(
807     g();
808 
809     // CHECK: call void @_ZN11ArrayAccess1AD
810     // CHECK: call void @_ZN11ArrayAccess1AD
811   }
812 }
813 
814 namespace PR14130 {
815   struct S { S(int); };
816   struct U { S &&s; };
817   U v { { 0 } };
818   // CHECK: call void @_ZN7PR141301SC1Ei({{.*}} @_ZGRN7PR141301vE_, i32 0)
819   // CHECK: store {{.*}} @_ZGRN7PR141301vE_, {{.*}} @_ZN7PR141301vE
820 }
821 
822 namespace Conditional {
823   struct A {};
824   struct B : A { B(); ~B(); };
825   struct C : A { C(); ~C(); };
826 
827   void g();
828 
829   // CHECK-LABEL: define {{.*}} @_ZN11Conditional1fEb(
830   void f(bool b) {
831     // CHECK: store i1 false, i1* %[[CLEANUP_B:.*]],
832     // CHECK: store i1 false, i1* %[[CLEANUP_C:.*]],
833     // CHECK: br i1
834     //
835     // CHECK: call {{.*}} @_ZN11Conditional1BC1Ev(
836     // CHECK: store i1 true, i1* %[[CLEANUP_B]],
837     // CHECK: br label
838     //
839     // CHECK: call {{.*}} @_ZN11Conditional1CC1Ev(
840     // CHECK: store i1 true, i1* %[[CLEANUP_C]],
841     // CHECK: br label
842     A &&r = b ? static_cast<A&&>(B()) : static_cast<A&&>(C());
843 
844     // CHECK: call {{.*}} @_ZN11Conditional1gEv(
845     g();
846 
847     // CHECK: load {{.*}} %[[CLEANUP_C]]
848     // CHECK: br i1
849     // CHECK: call {{.*}} @_ZN11Conditional1CD1Ev(
850     // CHECK: br label
851 
852     // CHECK: load {{.*}} %[[CLEANUP_B]]
853     // CHECK: br i1
854     // CHECK: call {{.*}} @_ZN11Conditional1BD1Ev(
855     // CHECK: br label
856   }
857 
858   struct D { A &&a; };
859   // CHECK-LABEL: define {{.*}} @_ZN11Conditional10f_indirectEb(
860   void f_indirect(bool b) {
861     // CHECK: store i1 false, i1* %[[CLEANUP_B:.*]],
862     // CHECK: store i1 false, i1* %[[CLEANUP_C:.*]],
863     // CHECK: br i1
864     //
865     // CHECK: call {{.*}} @_ZN11Conditional1BC1Ev(
866     // CHECK: store i1 true, i1* %[[CLEANUP_B]],
867     // CHECK: br label
868     //
869     // CHECK: call {{.*}} @_ZN11Conditional1CC1Ev(
870     // CHECK: store i1 true, i1* %[[CLEANUP_C]],
871     // CHECK: br label
872     D d = b ? D{B()} : D{C()};
873 
874     // In C++17, the expression D{...} directly initializes the 'd' object, so
875     // lifetime-extending the temporaries to the lifetime of the D object
876     // extends them past the call to g().
877     //
878     // In C++14 and before, D is move-constructed from the result of the
879     // conditional expression, so no lifetime extension occurs.
880 
881     // CHECK-CXX17: call {{.*}} @_ZN11Conditional1gEv(
882 
883     // CHECK: load {{.*}} %[[CLEANUP_C]]
884     // CHECK: br i1
885     // CHECK: call {{.*}} @_ZN11Conditional1CD1Ev(
886     // CHECK: br label
887 
888     // CHECK: load {{.*}} %[[CLEANUP_B]]
889     // CHECK: br i1
890     // CHECK: call {{.*}} @_ZN11Conditional1BD1Ev(
891     // CHECK: br label
892 
893     // CHECK-CXX11: call {{.*}} @_ZN11Conditional1gEv(
894     g();
895   }
896 
897   extern bool b;
898   // CHECK: load {{.*}} @_ZN11Conditional1b
899   // CHECK: br i1
900   //
901   // CHECK: call {{.*}} @_ZN11Conditional1BC1Ev({{.*}} @_ZGRN11Conditional1rE_)
902   // CHECK: call {{.*}} @__cxa_atexit({{.*}} @_ZN11Conditional1BD1Ev {{.*}} @_ZGRN11Conditional1rE_,
903   // CHECK: br label
904   //
905   // CHECK: call {{.*}} @_ZN11Conditional1CC1Ev({{.*}} @_ZGRN11Conditional1rE0_)
906   // CHECK: call {{.*}} @__cxa_atexit({{.*}} @_ZN11Conditional1CD1Ev {{.*}} @_ZGRN11Conditional1rE0_,
907   // CHECK: br label
908   A &&r = b ? static_cast<A&&>(B()) : static_cast<A&&>(C());
909 }
910 
911 #if __cplusplus >= 201703L
912 namespace PR42220 {
913   struct X { X(); ~X(); };
914   struct A { X &&x; };
915   struct B : A {};
916   void g() noexcept;
917   // CHECK-CXX17-LABEL: define{{.*}} @_ZN7PR422201fEv(
918   void f() {
919     // CHECK-CXX17: call{{.*}} @_ZN7PR422201XC1Ev(
920     B &&b = {X()};
921     // CHECK-CXX17-NOT: call{{.*}} @_ZN7PR422201XD1Ev(
922     // CHECK-CXX17: call{{.*}} @_ZN7PR422201gEv(
923     g();
924     // CHECK-CXX17: call{{.*}} @_ZN7PR422201XD1Ev(
925   }
926 }
927 #endif
928