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