1 // RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -emit-llvm -std=c++98 -o - -fcxx-exceptions -fexceptions | FileCheck -check-prefix=CHECK -check-prefix=CHECK98 %s
2 // RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -emit-llvm -std=c++11 -o - -fcxx-exceptions -fexceptions | FileCheck -check-prefix=CHECK -check-prefix=CHECK11 %s
4 typedef __typeof(sizeof(0)) size_t;
6 // Declare the reserved global placement new.
7 void *operator new(size_t, void*);
9 // This just shouldn't crash.
13 allocator(const allocator&);
18 void g(bool b, bool c) {
30 struct A { A(int); A(int, int); ~A(); void *p; };
33 // CHECK: define [[A:%.*]]* @_ZN5test11aEv()
34 // CHECK: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
35 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
36 // CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 5)
37 // CHECK: ret [[A]]* [[CAST]]
38 // CHECK: call void @_ZdlPv(i8* [[NEW]])
43 // CHECK: define [[A:%.*]]* @_ZN5test11bEv()
44 // CHECK: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
45 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
46 // CHECK-NEXT: [[FOO:%.*]] = invoke i32 @_ZN5test13fooEv()
47 // CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[FOO]])
48 // CHECK: ret [[A]]* [[CAST]]
49 // CHECK: call void @_ZdlPv(i8* [[NEW]])
54 struct B { B(); ~B(); operator int(); int x; };
58 // CHECK: define [[A:%.*]]* @_ZN5test11cEv()
59 // CHECK: [[ACTIVE:%.*]] = alloca i1
60 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
61 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
62 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
63 // CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
64 // CHECK: [[T1:%.*]] = getelementptr inbounds [[B]], [[B]]* [[T0]], i32 0, i32 0
65 // CHECK-NEXT: [[T2:%.*]] = load i32, i32* [[T1]], align 4
66 // CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T2]])
67 // CHECK: store i1 false, i1* [[ACTIVE]]
69 // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
70 // CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
72 // CHECK: ret [[A]]* [[CAST]]
73 // CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
74 // CHECK-NEXT: br i1 [[ISACTIVE]]
75 // CHECK: call void @_ZdlPv(i8* [[NEW]])
80 // Terminate landing pads should call __cxa_begin_catch first.
81 // CHECK98: define linkonce_odr hidden void @__clang_call_terminate(i8*) [[NI_NR_NUW:#[0-9]+]] comdat
82 // CHECK98-NEXT: [[T0:%.*]] = call i8* @__cxa_begin_catch(i8* %0) [[NUW:#[0-9]+]]
83 // CHECK98-NEXT: call void @_ZSt9terminatev() [[NR_NUW:#[0-9]+]]
84 // CHECK98-NEXT: unreachable
87 // CHECK: define [[A:%.*]]* @_ZN5test11dEv()
88 // CHECK: [[ACTIVE:%.*]] = alloca i1
89 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
90 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
91 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
92 // CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
93 // CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
94 // CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]])
95 // CHECK: store i1 false, i1* [[ACTIVE]]
97 // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
98 // CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
100 // CHECK: ret [[A]]* [[CAST]]
101 // CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
102 // CHECK-NEXT: br i1 [[ISACTIVE]]
103 // CHECK: call void @_ZdlPv(i8* [[NEW]])
108 // CHECK: define [[A:%.*]]* @_ZN5test11eEv()
109 // CHECK: [[ACTIVE:%.*]] = alloca i1
110 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
111 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
112 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
113 // CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
114 // CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
115 // CHECK: invoke void @_ZN5test11BC1Ev([[B]]* [[T2:%.*]])
116 // CHECK: [[T3:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T2]])
117 // CHECK: invoke void @_ZN5test11AC1Eii([[A]]* [[CAST]], i32 [[T1]], i32 [[T3]])
118 // CHECK: store i1 false, i1* [[ACTIVE]]
120 // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
121 // CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T2]])
123 // CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
124 // CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
126 // CHECK: ret [[A]]* [[CAST]]
127 // CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
128 // CHECK-NEXT: br i1 [[ISACTIVE]]
129 // CHECK: call void @_ZdlPv(i8* [[NEW]])
130 return new A(B(), B());
133 return new A(makeB().x);
136 return new A(makeB());
139 return new A(makeB(), makeB());
143 // CHECK: define [[A:%.*]]* @_ZN5test11iEv()
144 // CHECK: [[X:%.*]] = alloca [[A]]*, align 8
145 // CHECK: [[ACTIVE:%.*]] = alloca i1
146 // CHECK: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
147 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
148 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
149 // CHECK-NEXT: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret [[T0:%.*]])
150 // CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
151 // CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]])
152 // CHECK: store i1 false, i1* [[ACTIVE]]
153 // CHECK-NEXT: store [[A]]* [[CAST]], [[A]]** [[X]], align 8
154 // CHECK: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret [[T2:%.*]])
155 // CHECK: [[RET:%.*]] = load [[A]]*, [[A]]** [[X]], align 8
157 // CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
158 // CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T2]])
160 // CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
161 // CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
163 // CHECK: ret [[A]]* [[RET]]
164 // CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
165 // CHECK-NEXT: br i1 [[ISACTIVE]]
166 // CHECK: call void @_ZdlPv(i8* [[NEW]])
168 return (x = new A(makeB()), makeB(), x);
174 A(int); A(int, int); ~A();
176 void *operator new(size_t);
177 void operator delete(void*, size_t);
181 // CHECK: define [[A:%.*]]* @_ZN5test21aEv()
182 // CHECK: [[NEW:%.*]] = call i8* @_ZN5test21AnwEm(i64 8)
183 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
184 // CHECK-NEXT: invoke void @_ZN5test21AC1Ei([[A]]* [[CAST]], i32 5)
185 // CHECK: ret [[A]]* [[CAST]]
187 // CHECK98: invoke void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
188 // CHECK11: call void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
190 // CHECK98: call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
197 A(int); A(int, int); A(const A&); ~A();
199 void *operator new(size_t, void*, double);
200 void operator delete(void*, void*, double);
205 A makeA(), *makeAPtr();
208 // CHECK: define [[A:%.*]]* @_ZN5test31aEv()
209 // CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv()
210 // CHECK: [[BAR:%.*]] = call double @_ZN5test33barEv()
211 // CHECK: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[BAR]])
212 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
213 // CHECK-NEXT: invoke void @_ZN5test31AC1Ei([[A]]* [[CAST]], i32 5)
214 // CHECK: ret [[A]]* [[CAST]]
216 // CHECK98: invoke void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
217 // CHECK11: call void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
219 // CHECK98: call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
220 return new(foo(),bar()) A(5);
223 // rdar://problem/8439196
226 // CHECK: define [[A:%.*]]* @_ZN5test31bEb(i1 zeroext
227 // CHECK: [[SAVED0:%.*]] = alloca i8*
228 // CHECK-NEXT: [[SAVED1:%.*]] = alloca i8*
229 // CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1
231 // CHECK: [[COND:%.*]] = trunc i8 {{.*}} to i1
232 // CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]]
233 // CHECK-NEXT: br i1 [[COND]]
236 // CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv()
237 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[CONST:.*]])
238 // CHECK-NEXT: store i8* [[NEW]], i8** [[SAVED0]]
239 // CHECK-NEXT: store i8* [[FOO]], i8** [[SAVED1]]
240 // CHECK-NEXT: store i1 true, i1* [[CLEANUPACTIVE]]
241 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
242 // CHECK-NEXT: invoke void @_ZN5test35makeAEv([[A]]* sret [[CAST]])
245 new(foo(),10.0) A(makeA()) :
247 // CHECK: [[MAKE:%.*]] = call [[A]]* @_ZN5test38makeAPtrEv()
253 // CHECK: [[RESULT:%.*]] = phi [[A]]* {{.*}}[[CAST]]{{.*}}[[MAKE]]
254 // CHECK: ret [[A]]* [[RESULT]]
257 // CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[CLEANUPACTIVE]]
258 // CHECK-NEXT: br i1 [[ISACTIVE]]
259 // CHECK: [[V0:%.*]] = load i8*, i8** [[SAVED0]]
260 // CHECK-NEXT: [[V1:%.*]] = load i8*, i8** [[SAVED1]]
262 // CHECK98-NEXT: invoke void @_ZN5test31AdlEPvS1_d(i8* [[V0]], i8* [[V1]], double [[CONST]])
263 // CHECK11-NEXT: call void @_ZN5test31AdlEPvS1_d(i8* [[V0]], i8* [[V1]], double [[CONST]])
269 A(int); A(int, int); ~A();
271 void *operator new(size_t, void*, void*);
272 void operator delete(void*, size_t, void*, void*); // not a match
276 // CHECK: define [[A:%.*]]* @_ZN5test41aEv()
277 // CHECK: [[FOO:%.*]] = call i8* @_ZN5test43fooEv()
278 // CHECK-NEXT: [[BAR:%.*]] = call i8* @_ZN5test43barEv()
279 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test41AnwEmPvS1_(i64 8, i8* [[FOO]], i8* [[BAR]])
280 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
281 // CHECK-NEXT: call void @_ZN5test41AC1Ei([[A]]* [[CAST]], i32 5)
282 // CHECK-NEXT: ret [[A]]* [[CAST]]
283 extern void *foo(), *bar();
285 return new(foo(),bar()) A(5);
291 struct T { T(); ~T(); };
294 A(const A &x, const T &t = T());
300 // CHECK-LABEL: define void @_ZN5test54testEv()
301 // CHECK: [[EXNSLOT:%.*]] = alloca i8*
302 // CHECK-NEXT: [[SELECTORSLOT:%.*]] = alloca i32
303 // CHECK-NEXT: [[A:%.*]] = alloca [[A_T:%.*]], align 1
304 // CHECK-NEXT: [[T:%.*]] = alloca [[T_T:%.*]], align 1
305 // CHECK-NEXT: invoke void @_ZN5test53fooEv()
306 // CHECK: [[EXN:%.*]] = load i8*, i8** [[EXNSLOT]]
307 // CHECK-NEXT: [[ADJ:%.*]] = call i8* @__cxa_get_exception_ptr(i8* [[EXN]])
308 // CHECK-NEXT: [[SRC:%.*]] = bitcast i8* [[ADJ]] to [[A_T]]*
309 // CHECK-NEXT: invoke void @_ZN5test51TC1Ev([[T_T]]* [[T]])
310 // CHECK: invoke void @_ZN5test51AC1ERKS0_RKNS_1TE([[A_T]]* [[A]], [[A_T]]* dereferenceable({{[0-9]+}}) [[SRC]], [[T_T]]* dereferenceable({{[0-9]+}}) [[T]])
312 // CHECK98: invoke void @_ZN5test51TD1Ev([[T_T]]* [[T]])
313 // CHECK11: call void @_ZN5test51TD1Ev([[T_T]]* [[T]])
315 // CHECK98: call i8* @__cxa_begin_catch(i8* [[EXN]]) [[NUW]]
316 // CHECK98-NEXT: invoke void @_ZN5test51AD1Ev([[A_T]]* [[A]])
318 // CHECK: call void @__cxa_end_catch()
327 // PR9303: invalid assert on this
333 if (cond()) goto lbl;
341 struct A { A(); ~A(); };
343 // The throw() operator means that a bad allocation is signalled
344 // with a null return, which means that the initializer is
345 // evaluated conditionally.
346 static void *operator new(size_t size) throw();
352 // CHECK: define [[B:%.*]]* @_ZN5test74testEv()
353 // CHECK: [[OUTER_NEW:%.*]] = alloca i1
354 // CHECK-NEXT: alloca [[A:%.*]],
355 // CHECK-NEXT: alloca i8*
356 // CHECK-NEXT: alloca i32
357 // CHECK-NEXT: [[OUTER_A:%.*]] = alloca i1
358 // CHECK-NEXT: alloca i8*
359 // CHECK-NEXT: [[INNER_NEW:%.*]] = alloca i1
360 // CHECK-NEXT: alloca [[A]]
361 // CHECK-NEXT: [[INNER_A:%.*]] = alloca i1
363 // Allocate the outer object.
364 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
365 // CHECK-NEXT: icmp eq i8* [[NEW]], null
367 // These stores, emitted before the outermost conditional branch,
368 // deactivate the temporary cleanups.
369 // CHECK-NEXT: store i1 false, i1* [[OUTER_NEW]]
370 // CHECK-NEXT: store i1 false, i1* [[OUTER_A]]
371 // CHECK-NEXT: store i1 false, i1* [[INNER_NEW]]
372 // CHECK-NEXT: store i1 false, i1* [[INNER_A]]
375 // We passed the first null check; activate that cleanup and continue.
376 // CHECK: store i1 true, i1* [[OUTER_NEW]]
377 // CHECK-NEXT: bitcast
379 // Create the first A temporary and activate that cleanup.
380 // CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
381 // CHECK: store i1 true, i1* [[OUTER_A]]
383 // Allocate the inner object.
384 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
385 // CHECK-NEXT: icmp eq i8* [[NEW]], null
388 // We passed the second null check; save that pointer, activate
389 // that cleanup, and continue.
390 // CHECK: store i8* [[NEW]]
391 // CHECK-NEXT: store i1 true, i1* [[INNER_NEW]]
392 // CHECK-NEXT: bitcast
394 // Build the second A temporary and activate that cleanup.
395 // CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
396 // CHECK: store i1 true, i1* [[INNER_A]]
398 // Build the inner B object and deactivate the inner delete cleanup.
399 // CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
400 // CHECK: store i1 false, i1* [[INNER_NEW]]
403 // Build the outer B object and deactivate the outer delete cleanup.
404 // CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
405 // CHECK: store i1 false, i1* [[OUTER_NEW]]
407 // CHECK-NEXT: store [[B]]*
409 // Destroy the inner A object.
410 // CHECK-NEXT: load i1, i1* [[INNER_A]]
413 // CHECK98: invoke void @_ZN5test71AD1Ev(
414 // CHECK11: call void @_ZN5test71AD1Ev(
416 // Destroy the outer A object.
417 // CHECK: load i1, i1* [[OUTER_A]]
420 // CHECK98: invoke void @_ZN5test71AD1Ev(
421 // CHECK11: call void @_ZN5test71AD1Ev(
423 return new B(A(), new B(A(), 0));
430 // Having both of these is required to trigger the assert we're
433 A&operator=(const A&);
442 // CHECK-LABEL: define void @_ZN5test84testEv
445 // Make sure we generate the correct code for the delete[] call which
446 // happens if A::A() throws. (We were previously calling delete[] on
447 // a pointer to the first array element, not the pointer returned by new[].)
457 // CHECK: define {{%.*}}* @_ZN5test94testEv
458 // CHECK: [[TEST9_NEW:%.*]] = call i8* @_Znam
459 // CHECK: call void @_ZdaPv(i8* [[TEST9_NEW]])
462 // In a destructor with a function-try-block, a return statement in a
463 // catch handler behaves differently from running off the end of the
464 // catch handler. PR13102.
466 extern void cleanup();
467 extern bool suppress;
470 A::~A() try { cleanup(); } catch (...) { return; }
471 // CHECK-LABEL: define void @_ZN6test101AD1Ev(
472 // CHECK: invoke void @_ZN6test107cleanupEv()
473 // CHECK-NOT: rethrow
477 B::~B() try { cleanup(); } catch (...) {}
478 // CHECK-LABEL: define void @_ZN6test101BD1Ev(
479 // CHECK: invoke void @_ZN6test107cleanupEv()
480 // CHECK: call i8* @__cxa_begin_catch
481 // CHECK-NEXT: invoke void @__cxa_rethrow()
482 // CHECK: unreachable
485 C::~C() try { cleanup(); } catch (...) { if (suppress) return; }
486 // CHECK-LABEL: define void @_ZN6test101CD1Ev(
487 // CHECK: invoke void @_ZN6test107cleanupEv()
488 // CHECK: call i8* @__cxa_begin_catch
489 // CHECK-NEXT: load i8, i8* @_ZN6test108suppressE, align 1
493 // CHECK98: call void @__cxa_end_catch()
494 // CHECK98-NEXT: br label
495 // CHECK11: invoke void @__cxa_end_catch()
496 // CHECK11-NEXT: to label
498 // CHECK: invoke void @__cxa_rethrow()
499 // CHECK: unreachable
502 // Ensure that an exception in a constructor destroys
503 // already-constructed array members. PR14514
520 // CHECK-LABEL: define void @_ZN6test111CC2Ev(
521 // CHECK: [[THIS:%.*]] = load [[C:%.*]]*, [[C:%.*]]** {{%.*}}
523 // CHECK-NEXT: [[SINGLE:%.*]] = getelementptr inbounds [[C]], [[C]]* [[THIS]], i32 0, i32 0
524 // CHECK-NEXT: call void @_ZN6test111AC1Ev([[A:%.*]]* [[SINGLE]])
526 // CHECK-NEXT: [[ARRAY:%.*]] = getelementptr inbounds [[C]], [[C]]* [[THIS]], i32 0, i32 1
527 // CHECK-NEXT: [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A]]]], [2 x [3 x [[A]]]]* [[ARRAY]], i32 0, i32 0, i32 0
528 // CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ARRAYBEGIN]], i64 6
529 // CHECK-NEXT: br label
530 // CHECK: [[CUR:%.*]] = phi [[A]]* [ [[ARRAYBEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
531 // CHECK-NEXT: invoke void @_ZN6test111AC1Ev([[A:%.*]]* [[CUR]])
532 // CHECK: [[NEXT]] = getelementptr inbounds [[A]], [[A]]* [[CUR]], i64 1
533 // CHECK-NEXT: [[DONE:%.*]] = icmp eq [[A]]* [[NEXT]], [[ARRAYEND]]
534 // CHECK-NEXT: br i1 [[DONE]],
536 // CHECK: invoke void @__cxa_throw(
537 // Landing pad 1, from constructor in array-initialization loop:
539 // - First, destroy already-constructed bits of array.
540 // CHECK: [[EMPTY:%.*]] = icmp eq [[A]]* [[ARRAYBEGIN]], [[CUR]]
541 // CHECK-NEXT: br i1 [[EMPTY]]
542 // CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[CUR]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
543 // CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]], [[A]]* [[AFTER]], i64 -1
545 // CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
546 // CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
548 // CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
549 // CHECK-NEXT: br i1 [[DONE]],
550 // - Next, chain to cleanup for single.
552 // Landing pad 2, from throw site.
554 // - First, destroy all of array.
555 // CHECK: [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A]]]], [2 x [3 x [[A]]]]* [[ARRAY]], i32 0, i32 0, i32 0
556 // CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ARRAYBEGIN]], i64 6
557 // CHECK-NEXT: br label
558 // CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[ARRAYEND]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
559 // CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]], [[A]]* [[AFTER]], i64 -1
561 // CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
562 // CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
564 // CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
565 // CHECK-NEXT: br i1 [[DONE]],
566 // - Next, chain to cleanup for single.
568 // Finally, the cleanup for single.
570 // CHECK98: invoke void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
571 // CHECK11: call void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
575 // (After this is a terminate landingpad.)
580 void operator delete(void *, void *);
585 return new (ptr) A();
587 // CHECK-LABEL: define {{.*}} @_ZN6test124testEPv(
588 // CHECK: [[PTR:%.*]] = load i8*, i8*
589 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[PTR]] to [[A:%.*]]*
590 // CHECK-NEXT: invoke void @_ZN6test121AC1Ev([[A]]* [[CAST]])
591 // CHECK: ret [[A]]* [[CAST]]
593 // CHECK98: invoke void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
594 // CHECK11: call void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
597 // CHECK98: attributes [[NI_NR_NUW]] = { noinline noreturn nounwind }