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
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_,
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
18 extern const A &&a = (A&&)(A&&)(C&&)(C{});
19 // CHECK: @_ZGRN7PR162631aE_ = internal global {{.*}} zeroinitializer,
20 // CHECK: @_ZN7PR162631aE = constant {{.*}} bitcast ({{.*}}* @_ZGRN7PR162631aE_ to
22 extern const int &&t = ((B&&)C{}).n;
23 // CHECK: @_ZGRN7PR162631tE_ = internal global {{.*}} zeroinitializer,
24 // CHECK: @_ZN7PR162631tE = constant i32* {{.*}}* @_ZGRN7PR162631tE_ {{.*}} 4
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
34 struct B { virtual ~B(); };
37 A &&a = dynamic_cast<A&&>(A{});
38 // CHECK: @_ZGRN7PR202271aE_ = internal global
40 B &&b = dynamic_cast<C&&>(dynamic_cast<B&&>(C{}));
41 // CHECK: @_ZGRN7PR202271bE_ = internal global
43 B &&c = static_cast<C&&>(static_cast<B&&>(C{}));
44 // CHECK: @_ZGRN7PR202271cE_ = internal global
48 typedef const int &CIR;
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_
63 // CHECK: call void @_ZN1AC1Ev
64 // CHECK: call void @_ZN1AD1Ev
67 // CHECK: call void @_ZN1AC1Ev
68 // CHECK: call void @_ZN1AD1Ev
81 // CHECK-NOT: call void @_ZN1BC1Ev
82 // CHECK: call void @_ZN1BD1Ev
86 // Member function calls
95 // CHECK: call void @_ZN1CC1Ev
96 // CHECK: call void @_ZN1CD1Ev
97 // CHECK: call void @_ZN1CD1Ev
101 // Function call operator
110 // CHECK: call void @_ZN1DC1Ev
111 // CHECK: call void @_ZN1DD1Ev
112 // CHECK: call void @_ZN1DD1Ev
116 // Overloaded operators
120 E operator+(const E&);
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
132 // CHECK: call void @_ZN1EC1Ev
133 // CHECK: call void @_ZN1ED1Ev
134 // CHECK: call void @_ZN1ED1Ev
145 // CHECK: call void @_ZN1FC1Ev
146 // CHECK: call void @_ZN1FD1Ev
160 // CHECK: call void @_ZN1AC1Ev
161 // CHECK: call void @_Z1aRK1A
162 // CHECK: call void @_ZN1AD1Ev
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
192 // CHECK: call void @_ZN6PR50771AC1Ev
193 // CHECK: call i32 @_ZN6PR50771A1fEv
194 // CHECK: call void @_ZN6PR50771AD1Ev
196 // CHECK: call void @_ZN6PR50771AC1Ev
197 // CHECK: call i32 @_ZN6PR50771gERKNS_1AE
198 // CHECK: call void @_ZN6PR50771AD1Ev
201 // CHECK: call void @_ZN6PR50771fEv
208 // CHECK: call void @_ZN1AC1Ev
209 // CHECK-NOT: call void @_ZN1AD1Ev
221 // CHECK: call void @_ZN1HC1Ev
222 // CHECK: call void @_Z2f91H
223 // CHECK: call void @_ZN1HD1Ev
226 // CHECK: call void @_ZN1HC1ERKS_
227 // CHECK: call void @_Z2f91H
228 // CHECK: call void @_ZN1HD1Ev
235 // CHECK: call void @_ZN1HC1Ev
236 // CHECK: call void @_Z3f10RK1H
237 // CHECK: call void @_ZN1HD1Ev
240 // CHECK: call void @_Z3f10RK1H
241 // CHECK-NOT: call void @_ZN1HD1Ev
254 // CHECK: call void @_ZN1IC1EPKc
255 // CHECK-NOT: call void @_ZN1ID1Ev
269 // CHECK-LABEL: define void @_ZN6PR58671gEv
271 // CHECK: call void @_ZN6PR58671SC1Ev
272 // CHECK-NEXT: call void @_ZN6PR58671fENS_1SEi
273 // CHECK-NEXT: call void @_ZN6PR58671SD1Ev
274 // CHECK-NEXT: ret void
278 // CHECK-LABEL: define linkonce_odr void @_ZN6PR58672g2IiEEvT_
281 // CHECK: call void @_ZN6PR58671SC1Ev
282 // CHECK-NEXT: call void @_ZN6PR58671fENS_1SEi
283 // CHECK-NEXT: call void @_ZN6PR58671SD1Ev
284 // CHECK-NEXT: ret void
297 struct B { operator A(); };
299 // CHECK-LABEL: define weak_odr void @_ZN6PR61992f2IiEENS_1AET_
300 template<typename T> A f2(T) {
302 // CHECK: call void @_ZN6PR61991BcvNS_1AEEv
303 // CHECK-NEXT: ret void
307 template A f2<int>(int);
321 // CHECK-LABEL: define void @_ZN3T121gEv
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(
340 // NULL-INVALID: call nonnull %"struct.PR6648::D"* @_ZN6PR66483zedENS_1BE
341 // NULL-VALID: call %"struct.PR6648::D"* @_ZN6PR66483zedENS_1BE
346 namespace UserConvertToValue {
355 // CHECK: void @_ZN18UserConvertToValue1gEv()
357 // CHECK: call void @_ZN18UserConvertToValue1XC1Ei
358 // CHECK: call void @_ZN18UserConvertToValue1fENS_1XE
359 // CHECK: call void @_ZN18UserConvertToValue1XD1Ev
367 struct B { int i; ~B(); };
368 struct C { int C::*pm; ~C(); };
369 // CHECK-LABEL: define void @_ZN6PR75563fooEv()
371 // CHECK: call void @_ZN6PR75561AD1Ev
373 // CHECK: call void @llvm.memset.p0i8.i64
374 // CHECK: call void @_ZN6PR75561BD1Ev
376 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64
377 // CHECK: call void @_ZN6PR75561CD1Ev
379 // CHECK-NEXT: ret void
385 A(); A(const A &); ~A();
394 // CHECK-LABEL: define void @_ZN7Elision5test0Ev()
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
402 // CHECK-NEXT: call void @_ZN7Elision3fooEv()
403 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[I]])
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]])
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]])
416 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[K]])
417 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[J]])
418 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[I]])
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
427 // CHECK: call void @_ZN7Elision1AC1Ev([[A]]* [[I]])
428 // CHECK: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[I]], [[A]]* dereferenceable({{[0-9]+}}) [[X:%.*]])
431 // CHECK: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[J]], [[A]]* dereferenceable({{[0-9]+}}) [[X]])
432 // CHECK: call void @_ZN7Elision1AC1Ev([[A]]* [[J]])
435 // CHECK: call void @_ZN7Elision1AD1Ev([[A]]* [[J]])
436 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[I]])
439 // CHECK: define void @_ZN7Elision5test2Ev([[A]]* noalias sret
441 // CHECK: call void @_ZN7Elision3fooEv()
442 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[RET:%.*]])
443 // CHECK-NEXT: ret void
447 // CHECK: define void @_ZN7Elision5test3EiNS_1AE([[A]]* noalias sret
448 A test3(int v, A x) {
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);
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());
461 // CHECK-LABEL: define void @_ZN7Elision5test4Ev()
463 // CHECK: [[X:%.*]] = alloca [[A]], align 8
464 // CHECK-NEXT: [[XS:%.*]] = alloca [2 x [[A]]], align 16
466 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[X]])
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]])
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]],
484 // CHECK: call void @_ZN7Elision1AD1Ev([[A]]* [[X]])
487 // rdar://problem/8433352
488 // CHECK: define void @_ZN7Elision5test5Ev([[A]]* noalias sret
489 struct B { A a; B(); };
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
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]])
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]])
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]])
517 // CHECK: call void @_ZN7Elision1AD1Ev([[A]]* [[X]])
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
535 struct A { A(int); ~A(); };
537 // CHECK-LABEL: define void @_ZN6PR86233fooEb(
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]]
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]]
553 // CHECK: call void @_ZN6PR86231AD1Ev([[A]]* [[TMP]])
554 // CHECK-NEXT: br label
555 // CHECK: load i1, i1* [[LCONS]]
557 // CHECK: call void @_ZN6PR86231AD1Ev([[A]]* [[TMP]])
558 // CHECK-NEXT: br label
565 struct A { A(); ~A(); };
567 // CHECK-LABEL: define void @_ZN7PR113653fooEv(
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
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]]
582 namespace AssignmentOp {
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_(
592 // Ensure that each 'A' temporary is destroyed before the next subobject is
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(
603 namespace BindToSubobject {
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
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);
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()));
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();
648 struct S { int a : 5; ~S(); };
650 // Do not lifetime extend the S() temporary here.
652 // CHECK: call {{.*}}memset
653 // CHECK: store i32 {{.*}}, i32* @_ZGRN8Bitfield1rE_
654 // CHECK: call void @_ZN8Bitfield1SD1
655 // CHECK: store i32* @_ZGRN8Bitfield1rE_, i32** @_ZN8Bitfield1rE, align 8
660 typedef __attribute__((vector_size(16))) int vi4a;
661 typedef __attribute__((ext_vector_type(4))) int vi4b;
667 // CHECK: extractelement
668 // CHECK: store i32 {{.*}}, i32* @_ZGRN6Vector1rE_
669 // CHECK: store i32* @_ZGRN6Vector1rE_, i32** @_ZN6Vector1rE,
673 // CHECK: extractelement
674 // CHECK: store i32 {{.*}}, i32* @_ZGRN6Vector1sE_
675 // CHECK: store i32* @_ZGRN6Vector1sE_, i32** @_ZN6Vector1sE,
677 // FIXME PR16204: The following code leads to an assertion in Sema.
681 namespace ImplicitTemporaryCleanup {
682 struct A { A(int); ~A(); };
685 // CHECK-LABEL: define void @_ZN24ImplicitTemporaryCleanup1fEv(
687 // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1AC1Ei(
690 // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1gEv(
693 // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1AD1Ev(
697 namespace 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(); };
704 E &&e1 = { A(), B(), D().c };
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)
710 // CHECK: call void @_ZN17MultipleExtension1BC1Ev({{.*}} getelementptr inbounds ({{.*}} @[[TEMPE]], i32 0, i32 1))
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
718 E e2 = { A(), B(), D().c };
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)
724 // CHECK: call void @_ZN17MultipleExtension1BC1Ev({{.*}} getelementptr inbounds ({{.*}} @[[E]], i32 0, i32 1))
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]]
733 // CHECK: define void @[[NS:_ZN17MultipleExtension]]1fEv(
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:.*]]
748 // CHECK: call void @[[NS]]1gEv()
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]]
762 // CHECK: call void @[[NS]]1gEv()
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]])
773 namespace ArrayAccess {
774 struct A { A(int); ~A(); };
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];
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}];
795 // CHECK: call void @_ZN11ArrayAccess1gEv(
798 // CHECK: call void @_ZN11ArrayAccess1AD
799 // CHECK: call void @_ZN11ArrayAccess1AD
804 struct S { S(int); };
807 // CHECK: call void @_ZN7PR141301SC1Ei({{.*}} @_ZGRN7PR141301vE_, i32 0)
808 // CHECK: store {{.*}} @_ZGRN7PR141301vE_, {{.*}} @_ZN7PR141301vE
811 namespace Conditional {
813 struct B : A { B(); ~B(); };
814 struct C : A { C(); ~C(); };
818 // CHECK-LABEL: define {{.*}} @_ZN11Conditional1fEb(
820 // CHECK: store i1 false, i1* %[[CLEANUP_B:.*]],
821 // CHECK: store i1 false, i1* %[[CLEANUP_C:.*]],
824 // CHECK: call {{.*}} @_ZN11Conditional1BC1Ev(
825 // CHECK: store i1 true, i1* %[[CLEANUP_B]],
828 // CHECK: call {{.*}} @_ZN11Conditional1CC1Ev(
829 // CHECK: store i1 true, i1* %[[CLEANUP_C]],
831 A &&r = b ? static_cast<A&&>(B()) : static_cast<A&&>(C());
833 // CHECK: call {{.*}} @_ZN11Conditional1gEv(
836 // CHECK: load {{.*}} %[[CLEANUP_C]]
838 // CHECK: call {{.*}} @_ZN11Conditional1CD1Ev(
841 // CHECK: load {{.*}} %[[CLEANUP_B]]
843 // CHECK: call {{.*}} @_ZN11Conditional1BD1Ev(
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:.*]],
854 // CHECK: call {{.*}} @_ZN11Conditional1BC1Ev(
855 // CHECK: store i1 true, i1* %[[CLEANUP_B]],
858 // CHECK: call {{.*}} @_ZN11Conditional1CC1Ev(
859 // CHECK: store i1 true, i1* %[[CLEANUP_C]],
861 D d = b ? D{B()} : D{C()};
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().
867 // In C++14 and before, D is move-constructed from the result of the
868 // conditional expression, so no lifetime extension occurs.
870 // CHECK-CXX17: call {{.*}} @_ZN11Conditional1gEv(
872 // CHECK: load {{.*}} %[[CLEANUP_C]]
874 // CHECK: call {{.*}} @_ZN11Conditional1CD1Ev(
877 // CHECK: load {{.*}} %[[CLEANUP_B]]
879 // CHECK: call {{.*}} @_ZN11Conditional1BD1Ev(
882 // CHECK-CXX11: call {{.*}} @_ZN11Conditional1gEv(
887 // CHECK: load {{.*}} @_ZN11Conditional1b
890 // CHECK: call {{.*}} @_ZN11Conditional1BC1Ev({{.*}} @_ZGRN11Conditional1rE_)
891 // CHECK: call {{.*}} @__cxa_atexit({{.*}} @_ZN11Conditional1BD1Ev {{.*}} @_ZGRN11Conditional1rE_,
894 // CHECK: call {{.*}} @_ZN11Conditional1CC1Ev({{.*}} @_ZGRN11Conditional1rE0_)
895 // CHECK: call {{.*}} @__cxa_atexit({{.*}} @_ZN11Conditional1CD1Ev {{.*}} @_ZGRN11Conditional1rE0_,
897 A &&r = b ? static_cast<A&&>(B()) : static_cast<A&&>(C());