clang/test/CodeGenCXX/exceptions.cpp

   1 // RUN: %clang_cc1 -no-enable-noundef-analysis %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 -no-enable-noundef-analysis %s -triple=x86_64-linux-gnu -emit-llvm -std=c++11 -o - -fcxx-exceptions -fexceptions | FileCheck --check-prefixes=CHECK,CHECK11,THROWEND11 %s
   3 // RUN: %clang_cc1 -no-enable-noundef-analysis %s -triple=x86_64-linux-gnu -emit-llvm -std=c++11 -o - -fcxx-exceptions -fexceptions -fassume-nothrow-exception-dtor | FileCheck --check-prefixes=CHECK,CHECK11,NOTHROWEND11 %s
   4
   5 // CHECK: %[[STRUCT_TEST13_A:.*]] = type { i32, i32 }
   6
   7 typedef __typeof(sizeof(0)) size_t;
   8
   9 // Declare the reserved global placement new.
  10 void *operator new(size_t, void*);
  11
  12 // This just shouldn't crash.
  13 namespace test0 {
  14   struct allocator {
  15     allocator();
  16     allocator(const allocator&);
  17     ~allocator();
  18   };
  19
  20   void f();
  21   void g(bool b, bool c) {
  22     if (b) {
  23       if (!c)
  24         throw allocator();
  25
  26       return;
  27     }
  28     f();
  29   }
  30 }
  31
  32 namespace test1 {
  33   struct A { A(int); A(int, int); ~A(); void *p; };
  34
  35   A *a() {
  36     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11aEv()
  37     // CHECK:      [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
  38     // CHECK-NEXT: invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 5)
  39     // CHECK:      ret ptr [[NEW]]
  40     // CHECK:      call void @_ZdlPv(ptr [[NEW]])
  41     return new A(5);
  42   }
  43
  44   A *b() {
  45     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11bEv()
  46     // CHECK:      [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
  47     // CHECK-NEXT: [[FOO:%.*]] = invoke i32 @_ZN5test13fooEv()
  48     // CHECK:      invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 [[FOO]])
  49     // CHECK:      ret ptr [[NEW]]
  50     // CHECK:      call void @_ZdlPv(ptr [[NEW]])
  51     extern int foo();
  52     return new A(foo());
  53   }
  54
  55   struct B { B(); ~B(); operator int(); int x; };
  56   B makeB();
  57
  58   A *c() {
  59     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11cEv()
  60     // CHECK:      [[ACTIVE:%.*]] = alloca i1
  61     // CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
  62     // CHECK-NEXT: store i1 true, ptr [[ACTIVE]]
  63     // CHECK-NEXT: invoke void @_ZN5test11BC1Ev(ptr {{[^,]*}} [[T0:%.*]])
  64     // CHECK:      [[T1:%.*]] = getelementptr inbounds nuw [[B:%.*]], ptr [[T0]], i32 0, i32 0
  65     // CHECK-NEXT: [[T2:%.*]] = load i32, ptr [[T1]], align 4
  66     // CHECK-NEXT: invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 [[T2]])
  67     // CHECK:      store i1 false, ptr [[ACTIVE]]
  68
  69     // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
  70     // CHECK11-NEXT: call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
  71
  72     // CHECK:      ret ptr [[NEW]]
  73     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
  74     // CHECK-NEXT: br i1 [[ISACTIVE]]
  75     // CHECK:      call void @_ZdlPv(ptr [[NEW]])
  76     return new A(B().x);
  77   }
  78
  79   //   Terminate landing pads should call __cxa_begin_catch first.
  80   // CHECK98:      define linkonce_odr hidden void @__clang_call_terminate(ptr %0) [[NI_NR_NUW:#[0-9]+]] comdat
  81   // CHECK98-NEXT:   [[T0:%.*]] = call ptr @__cxa_begin_catch(ptr %0) [[NUW:#[0-9]+]]
  82   // CHECK98-NEXT:   call void @_ZSt9terminatev() [[NR_NUW:#[0-9]+]]
  83   // CHECK98-NEXT:   unreachable
  84
  85   A *d() {
  86     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11dEv()
  87     // CHECK:      [[ACTIVE:%.*]] = alloca i1
  88     // CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
  89     // CHECK-NEXT: store i1 true, ptr [[ACTIVE]]
  90     // CHECK-NEXT: invoke void @_ZN5test11BC1Ev(ptr {{[^,]*}} [[T0:%.*]])
  91     // CHECK:      [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv(ptr {{[^,]*}} [[T0]])
  92     // CHECK:      invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 [[T1]])
  93     // CHECK:      store i1 false, ptr [[ACTIVE]]
  94
  95     // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
  96     // CHECK11-NEXT: call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
  97
  98     // CHECK:      ret ptr [[NEW]]
  99     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
 100     // CHECK-NEXT: br i1 [[ISACTIVE]]
 101     // CHECK:      call void @_ZdlPv(ptr [[NEW]])
 102     return new A(B());
 103   }
 104
 105   A *e() {
 106     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11eEv()
 107     // CHECK:      [[ACTIVE:%.*]] = alloca i1
 108     // CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
 109     // CHECK-NEXT: store i1 true, ptr [[ACTIVE]]
 110     // CHECK-NEXT: invoke void @_ZN5test11BC1Ev(ptr {{[^,]*}} [[T0:%.*]])
 111     // CHECK:      [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv(ptr {{[^,]*}} [[T0]])
 112     // CHECK:      invoke void @_ZN5test11BC1Ev(ptr {{[^,]*}} [[T2:%.*]])
 113     // CHECK:      [[T3:%.*]] = invoke i32 @_ZN5test11BcviEv(ptr {{[^,]*}} [[T2]])
 114     // CHECK:      invoke void @_ZN5test11AC1Eii(ptr {{[^,]*}} [[NEW]], i32 [[T1]], i32 [[T3]])
 115     // CHECK:      store i1 false, ptr [[ACTIVE]]
 116
 117     // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T2]])
 118     // CHECK11-NEXT: call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T2]])
 119
 120     // CHECK98:      invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 121     // CHECK11:      call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 122
 123     // CHECK:      ret ptr [[NEW]]
 124     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
 125     // CHECK-NEXT: br i1 [[ISACTIVE]]
 126     // CHECK:      call void @_ZdlPv(ptr [[NEW]])
 127     return new A(B(), B());
 128   }
 129   A *f() {
 130     return new A(makeB().x);
 131   }
 132   A *g() {
 133     return new A(makeB());
 134   }
 135   A *h() {
 136     return new A(makeB(), makeB());
 137   }
 138
 139   A *i() {
 140     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11iEv()
 141     // CHECK:      [[X:%.*]] = alloca ptr, align 8
 142     // CHECK:      [[ACTIVE:%.*]] = alloca i1
 143     // CHECK:      [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
 144     // CHECK-NEXT: store i1 true, ptr [[ACTIVE]]
 145     // CHECK-NEXT: invoke void @_ZN5test15makeBEv(ptr dead_on_unwind writable sret([[B:%.*]]) align 4 [[T0:%.*]])
 146     // CHECK:      [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv(ptr {{[^,]*}} [[T0]])
 147     // CHECK:      invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 [[T1]])
 148     // CHECK:      store i1 false, ptr [[ACTIVE]]
 149     // CHECK-NEXT: store ptr [[NEW]], ptr [[X]], align 8
 150     // CHECK:      invoke void @_ZN5test15makeBEv(ptr dead_on_unwind writable sret([[B:%.*]]) align 4 [[T2:%.*]])
 151     // CHECK:      [[RET:%.*]] = load ptr, ptr [[X]], align 8
 152
 153     // CHECK98:      invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T2]])
 154     // CHECK11:      call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T2]])
 155
 156     // CHECK98:      invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 157     // CHECK11:      call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 158
 159     // CHECK:      ret ptr [[RET]]
 160     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
 161     // CHECK-NEXT: br i1 [[ISACTIVE]]
 162     // CHECK:      call void @_ZdlPv(ptr [[NEW]])
 163     A *x;
 164     return (x = new A(makeB()), makeB(), x);
 165   }
 166 }
 167
 168 namespace test2 {
 169   struct A {
 170     A(int); A(int, int); ~A();
 171     void *p;
 172     void *operator new(size_t);
 173     void operator delete(void*, size_t);
 174   };
 175
 176   A *a() {
 177     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test21aEv()
 178     // CHECK:      [[NEW:%.*]] = call ptr @_ZN5test21AnwEm(i64 8)
 179     // CHECK-NEXT: invoke void @_ZN5test21AC1Ei(ptr {{[^,]*}} [[NEW]], i32 5)
 180     // CHECK:      ret ptr [[NEW]]
 181
 182     // CHECK98:      invoke void @_ZN5test21AdlEPvm(ptr [[NEW]], i64 8)
 183     // CHECK11:      call void @_ZN5test21AdlEPvm(ptr [[NEW]], i64 8)
 184
 185     // CHECK98:      call void @__clang_call_terminate(ptr {{%.*}}) [[NR_NUW]]
 186     return new A(5);
 187   }
 188 }
 189
 190 namespace test3 {
 191   struct A {
 192     A(int); A(int, int); A(const A&); ~A();
 193     void *p;
 194     void *operator new(size_t, void*, double);
 195     void operator delete(void*, void*, double);
 196   };
 197
 198   void *foo();
 199   double bar();
 200   A makeA(), *makeAPtr();
 201
 202   A *a() {
 203     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test31aEv()
 204     // CHECK:      [[FOO:%.*]] = call ptr @_ZN5test33fooEv()
 205     // CHECK:      [[BAR:%.*]] = call double @_ZN5test33barEv()
 206     // CHECK:      [[NEW:%.*]] = call ptr @_ZN5test31AnwEmPvd(i64 8, ptr [[FOO]], double [[BAR]])
 207     // CHECK-NEXT: invoke void @_ZN5test31AC1Ei(ptr {{[^,]*}} [[NEW]], i32 5)
 208     // CHECK:      ret ptr [[NEW]]
 209
 210     // CHECK98:      invoke void @_ZN5test31AdlEPvS1_d(ptr [[NEW]], ptr [[FOO]], double [[BAR]])
 211     // CHECK11:      call void @_ZN5test31AdlEPvS1_d(ptr [[NEW]], ptr [[FOO]], double [[BAR]])
 212
 213     // CHECK98:      call void @__clang_call_terminate(ptr {{%.*}}) [[NR_NUW]]
 214     return new(foo(),bar()) A(5);
 215   }
 216
 217   A *b(bool cond) {
 218
 219     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test31bEb(i1 zeroext
 220     // CHECK:      [[SAVED0:%.*]] = alloca ptr
 221     // CHECK-NEXT: [[SAVED1:%.*]] = alloca ptr
 222     // CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1
 223
 224     // CHECK:      [[COND:%.*]] = trunc i8 {{.*}} to i1
 225     // CHECK-NEXT: store i1 false, ptr [[CLEANUPACTIVE]]
 226     // CHECK-NEXT: br i1 [[COND]]
 227     return (cond ?
 228
 229     // CHECK:      [[FOO:%.*]] = call ptr @_ZN5test33fooEv()
 230     // CHECK-NEXT: [[NEW:%.*]] = call ptr @_ZN5test31AnwEmPvd(i64 8, ptr [[FOO]], double [[CONST:.*]])
 231     // CHECK-NEXT: store ptr [[NEW]], ptr [[SAVED0]]
 232     // CHECK-NEXT: store ptr [[FOO]], ptr [[SAVED1]]
 233     // CHECK-NEXT: store i1 true, ptr [[CLEANUPACTIVE]]
 234     // CHECK-NEXT: invoke void @_ZN5test35makeAEv(ptr dead_on_unwind writable sret([[A:%.*]]) align 8 [[NEW]])
 235     // CHECK: br label
 236     //   -> cond.end
 237             new(foo(),10.0) A(makeA()) :
 238
 239     // CHECK:      [[MAKE:%.*]] = call ptr @_ZN5test38makeAPtrEv()
 240     // CHECK:      br label
 241     //   -> cond.end
 242             makeAPtr());
 243
 244     // cond.end:
 245     // CHECK:      [[RESULT:%.*]] = phi ptr {{.*}}[[NEW]]{{.*}}[[MAKE]]
 246     // CHECK:      ret ptr [[RESULT]]
 247
 248     // in the EH path:
 249     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[CLEANUPACTIVE]]
 250     // CHECK-NEXT: br i1 [[ISACTIVE]]
 251     // CHECK:      [[V0:%.*]] = load ptr, ptr [[SAVED0]]
 252     // CHECK-NEXT: [[V1:%.*]] = load ptr, ptr [[SAVED1]]
 253
 254     // CHECK98-NEXT: invoke void @_ZN5test31AdlEPvS1_d(ptr [[V0]], ptr [[V1]], double [[CONST]])
 255     // CHECK11-NEXT: call void @_ZN5test31AdlEPvS1_d(ptr [[V0]], ptr [[V1]], double [[CONST]])
 256   }
 257 }
 258
 259 namespace test4 {
 260   struct A {
 261     A(int); A(int, int); ~A();
 262     void *p;
 263     void *operator new(size_t, void*, void*);
 264     void operator delete(void*, size_t, void*, void*); // not a match
 265   };
 266
 267   A *a() {
 268     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test41aEv()
 269     // CHECK:      [[FOO:%.*]] = call ptr @_ZN5test43fooEv()
 270     // CHECK-NEXT: [[BAR:%.*]] = call ptr @_ZN5test43barEv()
 271     // CHECK-NEXT: [[NEW:%.*]] = call ptr @_ZN5test41AnwEmPvS1_(i64 8, ptr [[FOO]], ptr [[BAR]])
 272     // CHECK-NEXT: call void @_ZN5test41AC1Ei(ptr {{[^,]*}} [[NEW]], i32 5)
 273     // CHECK-NEXT: ret ptr [[NEW]]
 274     extern void *foo(), *bar();
 275
 276     return new(foo(),bar()) A(5);
 277   }
 278 }
 279
 280 // PR7908
 281 namespace test5 {
 282   struct T { T(); ~T(); };
 283
 284   struct A {
 285     A(const A &x, const T &t = T());
 286     ~A();
 287   };
 288
 289   void foo();
 290
 291   // CHECK-LABEL:    define{{.*}} void @_ZN5test54testEv()
 292   // CHECK:      [[EXNSLOT:%.*]] = alloca ptr
 293   // CHECK-NEXT: [[SELECTORSLOT:%.*]] = alloca i32
 294   // CHECK-NEXT: [[A:%.*]] = alloca [[A_T:%.*]], align 1
 295   // CHECK-NEXT: [[T:%.*]] = alloca [[T_T:%.*]], align 1
 296   // CHECK-NEXT: invoke void @_ZN5test53fooEv()
 297   // CHECK:      [[EXN:%.*]] = load ptr, ptr [[EXNSLOT]]
 298   // CHECK-NEXT: [[ADJ:%.*]] = call ptr @__cxa_get_exception_ptr(ptr [[EXN]])
 299   // CHECK-NEXT: invoke void @_ZN5test51TC1Ev(ptr {{[^,]*}} [[T]])
 300   // CHECK:      invoke void @_ZN5test51AC1ERKS0_RKNS_1TE(ptr {{[^,]*}} [[A:%.*]], ptr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[ADJ]], ptr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[T]])
 301
 302   // CHECK98:      invoke void @_ZN5test51TD1Ev(ptr {{[^,]*}} [[T]])
 303   // CHECK11:      call void @_ZN5test51TD1Ev(ptr {{[^,]*}} [[T]])
 304
 305   // CHECK98:      call ptr @__cxa_begin_catch(ptr [[EXN]]) [[NUW]]
 306   // CHECK98-NEXT: invoke void @_ZN5test51AD1Ev(ptr {{[^,]*}} [[A:%.*]])
 307
 308   // CHECK:      call void @__cxa_end_catch()
 309   void test() {
 310     try {
 311       foo();
 312     } catch (A a) {
 313     }
 314   }
 315 }
 316
 317 // PR9303: invalid assert on this
 318 namespace test6 {
 319   bool cond();
 320   void test() {
 321     try {
 322     lbl:
 323       if (cond()) goto lbl;
 324     } catch (...) {
 325     }
 326   }
 327 }
 328
 329 // PR9298
 330 namespace test7 {
 331   struct A { A(); ~A(); };
 332   struct B {
 333     // The throw() operator means that a bad allocation is signalled
 334     // with a null return, which means that the initializer is
 335     // evaluated conditionally.
 336     static void *operator new(size_t size) throw();
 337     B(const A&, B*);
 338     ~B();
 339   };
 340
 341   B *test() {
 342     // CHECK: define{{( dso_local)?}} ptr @_ZN5test74testEv()
 343     // CHECK:      [[OUTER_NEW:%.*]] = alloca i1
 344     // CHECK-NEXT: alloca [[A:%.*]],
 345     // CHECK-NEXT: alloca ptr
 346     // CHECK-NEXT: alloca i32
 347     // CHECK-NEXT: [[OUTER_A:%.*]] = alloca i1
 348     // CHECK-NEXT: alloca ptr
 349     // CHECK-NEXT: [[INNER_NEW:%.*]] = alloca i1
 350     // CHECK-NEXT: alloca [[A:%.*]]
 351     // CHECK-NEXT: [[INNER_A:%.*]] = alloca i1
 352
 353     // Allocate the outer object.
 354     // CHECK-NEXT: [[NEW:%.*]] = call ptr @_ZN5test71BnwEm(
 355     // CHECK-NEXT: icmp eq ptr [[NEW]], null
 356
 357     // These stores, emitted before the outermost conditional branch,
 358     // deactivate the temporary cleanups.
 359     // CHECK-NEXT: store i1 false, ptr [[OUTER_NEW]]
 360     // CHECK-NEXT: store i1 false, ptr [[OUTER_A]]
 361     // CHECK-NEXT: store i1 false, ptr [[INNER_NEW]]
 362     // CHECK-NEXT: store i1 false, ptr [[INNER_A]]
 363     // CHECK-NEXT: br i1
 364
 365     // We passed the first null check; activate that cleanup and continue.
 366     // CHECK:      store i1 true, ptr [[OUTER_NEW]]
 367
 368     // Create the first A temporary and activate that cleanup.
 369     // CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
 370     // CHECK:      store i1 true, ptr [[OUTER_A]]
 371
 372     // Allocate the inner object.
 373     // CHECK-NEXT: [[NEW:%.*]] = call ptr @_ZN5test71BnwEm(
 374     // CHECK-NEXT: icmp eq ptr [[NEW]], null
 375     // CHECK-NEXT: br i1
 376
 377     // We passed the second null check; save that pointer, activate
 378     // that cleanup, and continue.
 379     // CHECK:      store ptr [[NEW]]
 380     // CHECK-NEXT: store i1 true, ptr [[INNER_NEW]]
 381
 382     // Build the second A temporary and activate that cleanup.
 383     // CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
 384     // CHECK:      store i1 true, ptr [[INNER_A]]
 385
 386     // Build the inner B object and deactivate the inner delete cleanup.
 387     // CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
 388     // CHECK:      store i1 false, ptr [[INNER_NEW]]
 389     // CHECK:      phi
 390
 391     // Build the outer B object and deactivate the outer delete cleanup.
 392     // CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
 393     // CHECK:      store i1 false, ptr [[OUTER_NEW]]
 394     // CHECK:      phi
 395     // CHECK-NEXT: store ptr
 396
 397     // Destroy the inner A object.
 398     // CHECK-NEXT: load i1, ptr [[INNER_A]]
 399     // CHECK-NEXT: br i1
 400
 401     // CHECK98:    invoke void @_ZN5test71AD1Ev(
 402     // CHECK11:    call void @_ZN5test71AD1Ev(
 403
 404     // Destroy the outer A object.
 405     // CHECK:      load i1, ptr [[OUTER_A]]
 406     // CHECK-NEXT: br i1
 407
 408     // CHECK98:    invoke void @_ZN5test71AD1Ev(
 409     // CHECK11:    call void @_ZN5test71AD1Ev(
 410
 411     return new B(A(), new B(A(), 0));
 412   }
 413 }
 414
 415 // Just don't crash.
 416 namespace test8 {
 417   struct A {
 418     // Having both of these is required to trigger the assert we're
 419     // trying to avoid.
 420     A(const A&);
 421     A&operator=(const A&);
 422
 423     ~A();
 424   };
 425
 426   A makeA();
 427   void test() {
 428     throw makeA();
 429   }
 430   // CHECK-LABEL: define{{.*}} void @_ZN5test84testEv
 431 }
 432
 433 // Make sure we generate the correct code for the delete[] call which
 434 // happens if A::A() throws.  (We were previously calling delete[] on
 435 // a pointer to the first array element, not the pointer returned by new[].)
 436 // PR10870
 437 namespace test9 {
 438   struct A {
 439     A();
 440     ~A();
 441   };
 442   A* test() {
 443     return new A[10];
 444   }
 445   // CHECK: define{{.*}} ptr @_ZN5test94testEv
 446   // CHECK: [[TEST9_NEW:%.*]] = call noalias nonnull ptr @_Znam
 447   // CHECK: call void @_ZdaPv(ptr [[TEST9_NEW]])
 448 }
 449
 450 // In a destructor with a function-try-block, a return statement in a
 451 // catch handler behaves differently from running off the end of the
 452 // catch handler.  PR13102.
 453 namespace test10 {
 454   extern void cleanup();
 455   extern bool suppress;
 456
 457   struct A { ~A(); };
 458   A::~A() try { cleanup(); } catch (...) { return; }
 459   // CHECK-LABEL:    define{{.*}} void @_ZN6test101AD1Ev(
 460   // CHECK:      invoke void @_ZN6test107cleanupEv()
 461   // CHECK-NOT:  rethrow
 462   // CHECK:      ret void
 463
 464   struct B { ~B(); };
 465   B::~B() try { cleanup(); } catch (...) {}
 466   // CHECK-LABEL:    define{{.*}} void @_ZN6test101BD1Ev(
 467   // CHECK:      invoke void @_ZN6test107cleanupEv()
 468   // CHECK:      call ptr @__cxa_begin_catch
 469   // CHECK-NEXT: invoke void @__cxa_rethrow()
 470   // CHECK:      unreachable
 471
 472   struct C { ~C(); };
 473   C::~C() try { cleanup(); } catch (...) { if (suppress) return; }
 474   // CHECK-LABEL:    define{{.*}} void @_ZN6test101CD1Ev(
 475   // CHECK:      invoke void @_ZN6test107cleanupEv()
 476   // CHECK:      call ptr @__cxa_begin_catch
 477   // CHECK-NEXT: load i8, ptr @_ZN6test108suppressE, align 1
 478   // CHECK-NEXT: trunc
 479   // CHECK-NEXT: br i1
 480
 481   // CHECK98:      call void @__cxa_end_catch()
 482   // CHECK98-NEXT: br label
 483   // THROWEND11:        invoke void @__cxa_end_catch()
 484   // THROWEND11-NEXT:   to label %invoke.cont[[#]] unwind label %terminate.lpad
 485   // NOTHROWEND11:      call void @__cxa_end_catch()
 486   // NOTHROWEND11-NEXT: br label %try.cont
 487
 488   // CHECK:      invoke void @__cxa_rethrow()
 489   // CHECK:      unreachable
 490
 491   // CHECK:      terminate.lpad:
 492   // CHECK:        call void @__clang_call_terminate(
 493 }
 494
 495 // Ensure that an exception in a constructor destroys
 496 // already-constructed array members.  PR14514
 497 namespace test11 {
 498   struct A {
 499     A();
 500     ~A() {}
 501   };
 502
 503   struct C {
 504     A single;
 505     A array[2][3];
 506
 507     C();
 508   };
 509
 510   C::C() {
 511     throw 0;
 512   }
 513   // CHECK-LABEL:    define{{.*}} void @_ZN6test111CC2Ev(
 514   // CHECK:      [[THIS:%.*]] = load ptr, ptr {{%.*}}
 515   //   Construct single.
 516   // CHECK-NEXT: call void @_ZN6test111AC1Ev(ptr {{[^,]*}} [[THIS]])
 517   //   Construct array.
 518   // CHECK-NEXT: [[ARRAY:%.*]] = getelementptr inbounds nuw [[C:%.*]], ptr [[THIS]], i32 0, i32 1
 519   // CHECK-NEXT: [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A:%.*]]]], ptr [[ARRAY]], i32 0, i32 0, i32 0
 520   // CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A:%.*]], ptr [[ARRAYBEGIN]], i64 6
 521   // CHECK-NEXT: br label
 522   // CHECK:      [[CUR:%.*]] = phi ptr [ [[ARRAYBEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
 523   // CHECK-NEXT: invoke void @_ZN6test111AC1Ev(ptr {{[^,]*}} [[CUR]])
 524   // CHECK:      [[NEXT]] = getelementptr inbounds [[A:%.*]], ptr [[CUR]], i64 1
 525   // CHECK-NEXT: [[DONE:%.*]] = icmp eq ptr [[NEXT]], [[ARRAYEND]]
 526   // CHECK-NEXT: br i1 [[DONE]],
 527   //   throw 0;
 528   // CHECK:      invoke void @__cxa_throw(
 529   //   Landing pad 1, from constructor in array-initialization loop:
 530   // CHECK:      landingpad
 531   //     - First, destroy already-constructed bits of array.
 532   // CHECK:      [[EMPTY:%.*]] = icmp eq ptr [[ARRAYBEGIN]], [[CUR]]
 533   // CHECK-NEXT: br i1 [[EMPTY]]
 534   // CHECK:      [[AFTER:%.*]] = phi ptr [ [[CUR]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
 535   // CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A:%.*]], ptr [[AFTER]], i64 -1
 536
 537   // CHECK98-NEXT: invoke void @_ZN6test111AD1Ev(ptr {{[^,]*}} [[ELT]])
 538   // CHECK11-NEXT: call void @_ZN6test111AD1Ev(ptr {{[^,]*}} [[ELT]])
 539
 540   // CHECK:      [[DONE:%.*]] = icmp eq ptr [[ELT]], [[ARRAYBEGIN]]
 541   // CHECK-NEXT: br i1 [[DONE]],
 542   //     - Next, chain to cleanup for single.
 543   // CHECK:      br label
 544   //   Landing pad 2, from throw site.
 545   // CHECK:      landingpad
 546   //     - First, destroy all of array.
 547   // CHECK:      [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A:%.*]]]], ptr [[ARRAY]], i32 0, i32 0, i32 0
 548   // CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A:%.*]], ptr [[ARRAYBEGIN]], i64 6
 549   // CHECK-NEXT: br label
 550   // CHECK:      [[AFTER:%.*]] = phi ptr [ [[ARRAYEND]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
 551   // CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]], ptr [[AFTER]], i64 -1
 552
 553   // CHECK98-NEXT: invoke void @_ZN6test111AD1Ev(ptr {{[^,]*}} [[ELT]])
 554   // CHECK11-NEXT: call void @_ZN6test111AD1Ev(ptr {{[^,]*}} [[ELT]])
 555
 556   // CHECK:      [[DONE:%.*]] = icmp eq ptr [[ELT]], [[ARRAYBEGIN]]
 557   // CHECK-NEXT: br i1 [[DONE]],
 558   //     - Next, chain to cleanup for single.
 559   // CHECK:      br label
 560   //   Finally, the cleanup for single.
 561
 562   // CHECK98:      invoke void @_ZN6test111AD1Ev(ptr {{[^,]*}} [[THIS]])
 563   // CHECK11:      call void @_ZN6test111AD1Ev(ptr {{[^,]*}} [[THIS]])
 564
 565   // CHECK:      br label
 566   // CHECK:      resume
 567   //   (After this is a terminate landingpad.)
 568 }
 569
 570 namespace test12 {
 571   struct A {
 572     void operator delete(void *, void *);
 573     A();
 574   };
 575
 576   A *test(void *ptr) {
 577     return new (ptr) A();
 578   }
 579   // CHECK-LABEL: define {{.*}} @_ZN6test124testEPv(
 580   // CHECK:       [[PTR:%.*]] = load ptr, ptr
 581   // CHECK-NEXT:  invoke void @_ZN6test121AC1Ev(ptr {{[^,]*}} [[PTR]])
 582   // CHECK:       ret ptr [[PTR]]
 583
 584   // CHECK98:       invoke void @_ZN6test121AdlEPvS1_(ptr [[PTR]], ptr [[PTR]])
 585   // CHECK11:       call void @_ZN6test121AdlEPvS1_(ptr [[PTR]], ptr [[PTR]])
 586 }
 587
 588 namespace test13 {
 589
 590 struct A {
 591   A();
 592   ~A();
 593   int a, b;
 594 };
 595
 596 // CHECK: define{{.*}} void @_ZN6test134testEi(
 597 // CHECK: %[[REF_TMP:.*]] = alloca %[[STRUCT_TEST13_A]], align 4
 598 // CHECK: %[[CLEANUP_COND:.*]] = alloca i1, align 1
 599 // CHECK: %[[REF_TMP1:.*]] = alloca %[[STRUCT_TEST13_A]], align 4
 600 // CHECK: %[[CLEANUP_COND2:.*]] = alloca i1, align 1
 601
 602 // CHECK: call void @_ZN6test131AC1Ev(ptr {{[^,]*}} %[[REF_TMP]])
 603 // CHECK: store i1 true, ptr %[[CLEANUP_COND]], align 1
 604 // CHECK: br
 605
 606 // CHECK: invoke void @_ZN6test131AC1Ev(ptr {{[^,]*}} %[[REF_TMP1]])
 607
 608 // CHECK: store i1 true, ptr %[[CLEANUP_COND2]], align 1
 609 // CHECK: br
 610
 611 // Check the flag before destructing the temporary.
 612
 613 // CHECK: landingpad { ptr, i32 }
 614 // CHECK: %[[CLEANUP_IS_ACTIVE:.*]] = load i1, ptr %[[CLEANUP_COND]], align 1
 615 // CHECK: br i1 %[[CLEANUP_IS_ACTIVE]],
 616
 617 // CHECK: void @_ZN6test131AD1Ev(ptr {{[^,]*}} %[[REF_TMP]])
 618
 619 void test(int c) {
 620   const A &s = c ? static_cast<const A &>(A()) : static_cast<const A &>(A());
 621 }
 622
 623 }
 624
 625 // CHECK98: attributes [[NI_NR_NUW]] = { noinline noreturn nounwind {{.*}} }