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