Clang Project

clang_source_code/test/CodeGenCXX/exceptions.cpp
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
3
4typedef __typeof(sizeof(0)) size_t;
5
6// Declare the reserved global placement new.
7void *operator new(size_t, void*);
8
9// This just shouldn't crash.
10namespace test0 {
11  struct allocator {
12    allocator();
13    allocator(const allocator&);
14    ~allocator();
15  };
16
17  void f();
18  void g(bool b, bool c) {
19    if (b) {
20      if (!c)
21        throw allocator();
22
23      return;
24    }
25    f();
26  }
27}
28
29namespace test1 {
30  struct A { A(int); A(int, int); ~A(); void *p; };
31
32  A *a() {
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]])
39    return new A(5);
40  }
41
42  A *b() {
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]])
50    extern int foo();
51    return new A(foo());
52  }
53
54  struct B { B(); ~B(); operator int(); int x; };
55  B makeB();
56
57  A *c() {
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]]
68
69    // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
70    // CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
71
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]])
76    return new A(B().x);
77  }
78
79  //   rdar://11904428
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
85
86  A *d() {
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]]
96
97    // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
98    // CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
99
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]])
104    return new A(B());
105  }
106
107  A *e() {
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]]
119
120    // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
121    // CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T2]])
122
123    // CHECK98:      invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
124    // CHECK11:      call void @_ZN5test11BD1Ev([[B]]* [[T0]])
125
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());
131  }
132  A *f() {
133    return new A(makeB().x);
134  }
135  A *g() {
136    return new A(makeB());
137  }
138  A *h() {
139    return new A(makeB(), makeB());
140  }
141
142  A *i() {
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
156
157    // CHECK98:      invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
158    // CHECK11:      call void @_ZN5test11BD1Ev([[B]]* [[T2]])
159
160    // CHECK98:      invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
161    // CHECK11:      call void @_ZN5test11BD1Ev([[B]]* [[T0]])
162
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]])
167    A *x;
168    return (x = new A(makeB()), makeB(), x);
169  }
170}
171
172namespace test2 {
173  struct A {
174    A(int); A(int, int); ~A();
175    void *p;
176    void *operator new(size_t);
177    void operator delete(void*, size_t);
178  };
179
180  A *a() {
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]]
186
187    // CHECK98:      invoke void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
188    // CHECK11:      call void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
189
190    // CHECK98:      call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
191    return new A(5);
192  }
193}
194
195namespace test3 {
196  struct A {
197    A(int); A(int, int); A(const A&); ~A();
198    void *p;
199    void *operator new(size_t, void*, double);
200    void operator delete(void*, void*, double);
201  };
202
203  void *foo();
204  double bar();
205  A makeA(), *makeAPtr();
206
207  A *a() {
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]]
215
216    // CHECK98:      invoke void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
217    // CHECK11:      call void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
218
219    // CHECK98:      call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
220    return new(foo(),bar()) A(5);
221  }
222
223  // rdar://problem/8439196
224  A *b(bool cond) {
225
226    // CHECK:    define [[A:%.*]]* @_ZN5test31bEb(i1 zeroext
227    // CHECK:      [[SAVED0:%.*]] = alloca i8*
228    // CHECK-NEXT: [[SAVED1:%.*]] = alloca i8*
229    // CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1
230
231    // CHECK:      [[COND:%.*]] = trunc i8 {{.*}} to i1
232    // CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]]
233    // CHECK-NEXT: br i1 [[COND]]
234    return (cond ?
235
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]])
243    // CHECK: br label
244    //   -> cond.end
245            new(foo(),10.0) A(makeA()) :
246
247    // CHECK:      [[MAKE:%.*]] = call [[A]]* @_ZN5test38makeAPtrEv()
248    // CHECK:      br label
249    //   -> cond.end
250            makeAPtr());
251
252    // cond.end:
253    // CHECK:      [[RESULT:%.*]] = phi [[A]]* {{.*}}[[CAST]]{{.*}}[[MAKE]]
254    // CHECK:      ret [[A]]* [[RESULT]]
255
256    // in the EH path:
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]]
261
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]])
264  }
265}
266
267namespace test4 {
268  struct A {
269    A(int); A(int, int); ~A();
270    void *p;
271    void *operator new(size_t, void*, void*);
272    void operator delete(void*, size_t, void*, void*); // not a match
273  };
274
275  A *a() {
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();
284
285    return new(foo(),bar()) A(5);
286  }
287}
288
289// PR7908
290namespace test5 {
291  struct T { T(); ~T(); };
292
293  struct A {
294    A(const A &x, const T &t = T());
295    ~A();
296  };
297
298  void foo();
299
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]])
311
312  // CHECK98:      invoke void @_ZN5test51TD1Ev([[T_T]]* [[T]])
313  // CHECK11:      call void @_ZN5test51TD1Ev([[T_T]]* [[T]])
314
315  // CHECK98:      call i8* @__cxa_begin_catch(i8* [[EXN]]) [[NUW]]
316  // CHECK98-NEXT: invoke void @_ZN5test51AD1Ev([[A_T]]* [[A]])
317
318  // CHECK:      call void @__cxa_end_catch()
319  void test() {
320    try {
321      foo();
322    } catch (A a) {
323    }
324  }
325}
326
327// PR9303: invalid assert on this
328namespace test6 {
329  bool cond();
330  void test() {
331    try {
332    lbl:
333      if (cond()) goto lbl;
334    } catch (...) {
335    }
336  }
337}
338
339// PR9298
340namespace test7 {
341  struct A { A(); ~A(); };
342  struct B {
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();
347    B(const A&, B*);
348    ~B();
349  };
350
351  B *test() {
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
362
363    // Allocate the outer object.
364    // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
365    // CHECK-NEXT: icmp eq i8* [[NEW]], null
366
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]]
373    // CHECK-NEXT: br i1
374
375    // We passed the first null check; activate that cleanup and continue.
376    // CHECK:      store i1 true, i1* [[OUTER_NEW]]
377    // CHECK-NEXT: bitcast
378
379    // Create the first A temporary and activate that cleanup.
380    // CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
381    // CHECK:      store i1 true, i1* [[OUTER_A]]
382
383    // Allocate the inner object.
384    // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
385    // CHECK-NEXT: icmp eq i8* [[NEW]], null
386    // CHECK-NEXT: br i1
387
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
393
394    // Build the second A temporary and activate that cleanup.
395    // CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
396    // CHECK:      store i1 true, i1* [[INNER_A]]
397
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]]
401    // CHECK:      phi
402
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]]
406    // CHECK:      phi
407    // CHECK-NEXT: store [[B]]*
408
409    // Destroy the inner A object.
410    // CHECK-NEXT: load i1, i1* [[INNER_A]]
411    // CHECK-NEXT: br i1
412
413    // CHECK98:    invoke void @_ZN5test71AD1Ev(
414    // CHECK11:    call void @_ZN5test71AD1Ev(
415
416    // Destroy the outer A object.
417    // CHECK:      load i1, i1* [[OUTER_A]]
418    // CHECK-NEXT: br i1
419
420    // CHECK98:    invoke void @_ZN5test71AD1Ev(
421    // CHECK11:    call void @_ZN5test71AD1Ev(
422
423    return new B(A(), new B(A(), 0));
424  }
425}
426
427// Just don't crash.
428namespace test8 {
429  struct A {
430    // Having both of these is required to trigger the assert we're
431    // trying to avoid.
432    A(const A&);
433    A&operator=(const A&);
434
435    ~A();
436  };
437
438  A makeA();
439  void test() {
440    throw makeA();
441  }
442  // CHECK-LABEL: define void @_ZN5test84testEv
443}
444
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[].)
448// PR10870
449namespace test9 {
450  struct A {
451    A();
452    ~A();
453  };
454  A* test() {
455    return new A[10];
456  }
457  // CHECK: define {{%.*}}* @_ZN5test94testEv
458  // CHECK: [[TEST9_NEW:%.*]] = call i8* @_Znam
459  // CHECK: call void @_ZdaPv(i8* [[TEST9_NEW]])
460}
461
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.
465namespace test10 {
466  extern void cleanup();
467  extern bool suppress;
468
469  struct A { ~A(); };
470  A::~A() try { cleanup(); } catch (...) { return; }
471  // CHECK-LABEL:    define void @_ZN6test101AD1Ev(
472  // CHECK:      invoke void @_ZN6test107cleanupEv()
473  // CHECK-NOT:  rethrow
474  // CHECK:      ret void
475
476  struct B { ~B(); };
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
483
484  struct C { ~C(); };
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
490  // CHECK-NEXT: trunc
491  // CHECK-NEXT: br i1
492
493  // CHECK98:      call void @__cxa_end_catch()
494  // CHECK98-NEXT: br label
495  // CHECK11:      invoke void @__cxa_end_catch()
496  // CHECK11-NEXT: to label
497
498  // CHECK:      invoke void @__cxa_rethrow()
499  // CHECK:      unreachable
500}
501
502// Ensure that an exception in a constructor destroys
503// already-constructed array members.  PR14514
504namespace test11 {
505  struct A {
506    A();
507    ~A() {}
508  };
509
510  struct C {
511    A single;
512    A array[2][3];
513
514    C();
515  };
516
517  C::C() {
518    throw 0;
519  }
520  // CHECK-LABEL:    define void @_ZN6test111CC2Ev(
521  // CHECK:      [[THIS:%.*]] = load [[C:%.*]]*, [[C:%.*]]** {{%.*}}
522  //   Construct single.
523  // CHECK-NEXT: [[SINGLE:%.*]] = getelementptr inbounds [[C]], [[C]]* [[THIS]], i32 0, i32 0
524  // CHECK-NEXT: call void @_ZN6test111AC1Ev([[A:%.*]]* [[SINGLE]])
525  //   Construct array.
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]],
535  //   throw 0;
536  // CHECK:      invoke void @__cxa_throw(
537  //   Landing pad 1, from constructor in array-initialization loop:
538  // CHECK:      landingpad
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
544
545  // CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
546  // CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
547
548  // CHECK:      [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
549  // CHECK-NEXT: br i1 [[DONE]],
550  //     - Next, chain to cleanup for single.
551  // CHECK:      br label
552  //   Landing pad 2, from throw site.
553  // CHECK:      landingpad
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
560
561  // CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
562  // CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
563
564  // CHECK:      [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
565  // CHECK-NEXT: br i1 [[DONE]],
566  //     - Next, chain to cleanup for single.
567  // CHECK:      br label
568  //   Finally, the cleanup for single.
569
570  // CHECK98:      invoke void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
571  // CHECK11:      call void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
572
573  // CHECK:      br label
574  // CHECK:      resume
575  //   (After this is a terminate landingpad.)
576}
577
578namespace test12 {
579  struct A {
580    void operator delete(void *, void *);
581    A();
582  };
583
584  A *test(void *ptr) {
585    return new (ptr) A();
586  }
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]]
592
593  // CHECK98:       invoke void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
594  // CHECK11:       call void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
595}
596
597// CHECK98: attributes [[NI_NR_NUW]] = { noinline noreturn nounwind }
598
CodeThinker, Enjoy your reading code