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