Clang Project

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