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