clang/test/CodeGenCXX/eh.cpp

   1 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -triple x86_64-apple-macosx10.13.99 -std=c++11 -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=UNALIGNED %s
   2 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -triple x86_64-apple-macosx10.14 -std=c++11 -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=ALIGNED %s
   3
   4 struct test1_D {
   5   double d;
   6 } d1;
   7
   8 void test1() {
   9   throw d1;
  10 }
  11
  12 // CHECK-LABEL:     define{{.*}} void @_Z5test1v()
  13 // CHECK:       [[EXNOBJ:%.*]] = call ptr @__cxa_allocate_exception(i64 8)
  14 // UNALIGNED-NEXT:  call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[EXNOBJ]], ptr align 8 @d1, i64 8, i1 false)
  15 // ALIGNED-NEXT:  call void @llvm.memcpy.p0.p0.i64(ptr align 16 [[EXNOBJ]], ptr align 8 @d1, i64 8, i1 false)
  16 // CHECK-NEXT:  call void @__cxa_throw(ptr [[EXNOBJ]], ptr @_ZTI7test1_D, ptr null) [[NR:#[0-9]+]]
  17 // CHECK-NEXT:  unreachable
  18
  19
  20 struct test2_D {
  21   test2_D(const test2_D&o);
  22   test2_D();
  23   virtual void bar() { }
  24   int i; int j;
  25 } d2;
  26
  27 void test2() {
  28   throw d2;
  29 }
  30
  31 // CHECK-LABEL:     define{{.*}} void @_Z5test2v()
  32 // CHECK:       [[EXNVAR:%.*]] = alloca ptr
  33 // CHECK-NEXT:  [[SELECTORVAR:%.*]] = alloca i32
  34 // CHECK-NEXT:  [[EXNOBJ:%.*]] = call ptr @__cxa_allocate_exception(i64 16)
  35 // CHECK-NEXT:  invoke void @_ZN7test2_DC1ERKS_(ptr {{[^,]*}} [[EXNOBJ]], ptr noundef nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) @d2)
  36 // CHECK-NEXT:     to label %[[CONT:.*]] unwind label %{{.*}}
  37 //      :     [[CONT]]:   (can't check this in Release-Asserts builds)
  38 // CHECK:       call void @__cxa_throw(ptr [[EXNOBJ]], ptr @_ZTI7test2_D, ptr null) [[NR]]
  39 // CHECK-NEXT:  unreachable
  40
  41
  42 struct test3_D {
  43   test3_D() { }
  44   test3_D(volatile test3_D&o);
  45   virtual void bar();
  46 };
  47
  48 void test3() {
  49   throw (volatile test3_D *)0;
  50 }
  51
  52 // CHECK-LABEL:     define{{.*}} void @_Z5test3v()
  53 // CHECK:       [[EXNOBJ:%.*]] = call ptr @__cxa_allocate_exception(i64 8)
  54 // CHECK-NEXT:  store ptr null, ptr [[EXNOBJ]]
  55 // CHECK-NEXT:  call void @__cxa_throw(ptr [[EXNOBJ]], ptr @_ZTIPV7test3_D, ptr null) [[NR]]
  56 // CHECK-NEXT:  unreachable
  57
  58
  59 void test4() {
  60   throw;
  61 }
  62
  63 // CHECK-LABEL:     define{{.*}} void @_Z5test4v()
  64 // CHECK:        call void @__cxa_rethrow() [[NR]]
  65 // CHECK-NEXT:   unreachable
  66
  67 namespace test5 {
  68   struct A {
  69     A();
  70     A(const A&);
  71     ~A();
  72   };
  73
  74   void test() {
  75     try { throw A(); } catch (A &x) {}
  76   }
  77 // CHECK-LABEL:      define{{.*}} void @_ZN5test54testEv()
  78 // CHECK:      [[EXNOBJ:%.*]] = call ptr @__cxa_allocate_exception(i64 1)
  79 // CHECK: invoke void @_ZN5test51AC1Ev(ptr {{[^,]*}} [[EXNOBJ]])
  80 // CHECK:      invoke void @__cxa_throw(ptr [[EXNOBJ]], ptr @_ZTIN5test51AE, ptr @_ZN5test51AD1Ev) [[NR]]
  81 // CHECK-NEXT:   to label {{%.*}} unwind label %[[HANDLER:[^ ]*]]
  82 //      :    [[HANDLER]]:  (can't check this in Release-Asserts builds)
  83 // CHECK:      {{%.*}} = call i32 @llvm.eh.typeid.for(ptr @_ZTIN5test51AE)
  84 }
  85
  86 namespace test6 {
  87   template <class T> struct allocator {
  88     ~allocator() throw() { }
  89   };
  90
  91   void foo() {
  92     allocator<int> a;
  93   }
  94 }
  95
  96 // PR7127
  97 namespace test7 {
  98 // CHECK-LABEL:      define{{.*}} i32 @_ZN5test73fooEv()
  99 // CHECK-SAME:  personality ptr @__gxx_personality_v0
 100   int foo() {
 101 // CHECK:      [[CAUGHTEXNVAR:%.*]] = alloca ptr
 102 // CHECK-NEXT: [[SELECTORVAR:%.*]] = alloca i32
 103 // CHECK-NEXT: [[INTCATCHVAR:%.*]] = alloca i32
 104     try {
 105       try {
 106 // CHECK-NEXT: [[EXNALLOC:%.*]] = call ptr @__cxa_allocate_exception
 107 // CHECK-NEXT: store i32 1, ptr
 108 // CHECK-NEXT: invoke void @__cxa_throw(ptr [[EXNALLOC]], ptr @_ZTIi, ptr null
 109         throw 1;
 110       }
 111
 112 // CHECK:      [[CAUGHTVAL:%.*]] = landingpad { ptr, i32 }
 113 // CHECK-NEXT:   catch ptr @_ZTIi
 114 // CHECK-NEXT:   catch ptr null
 115 // CHECK-NEXT: [[CAUGHTEXN:%.*]] = extractvalue { ptr, i32 } [[CAUGHTVAL]], 0
 116 // CHECK-NEXT: store ptr [[CAUGHTEXN]], ptr [[CAUGHTEXNVAR]]
 117 // CHECK-NEXT: [[SELECTOR:%.*]] = extractvalue { ptr, i32 } [[CAUGHTVAL]], 1
 118 // CHECK-NEXT: store i32 [[SELECTOR]], ptr [[SELECTORVAR]]
 119 // CHECK-NEXT: br label
 120 // CHECK:      [[SELECTOR:%.*]] = load i32, ptr [[SELECTORVAR]]
 121 // CHECK-NEXT: [[T0:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi)
 122 // CHECK-NEXT: icmp eq i32 [[SELECTOR]], [[T0]]
 123 // CHECK-NEXT: br i1
 124 // CHECK:      [[T0:%.*]] = load ptr, ptr [[CAUGHTEXNVAR]]
 125 // CHECK-NEXT: [[T1:%.*]] = call ptr @__cxa_begin_catch(ptr [[T0]])
 126 // CHECK-NEXT: [[T3:%.*]] = load i32, ptr [[T1]]
 127 // CHECK-NEXT: store i32 [[T3]], ptr {{%.*}}, align 4
 128 // CHECK-NEXT: invoke void @__cxa_rethrow
 129       catch (int) {
 130         throw;
 131       }
 132     }
 133 // CHECK:      [[CAUGHTVAL:%.*]] = landingpad { ptr, i32 }
 134 // CHECK-NEXT:   catch ptr null
 135 // CHECK-NEXT: [[CAUGHTEXN:%.*]] = extractvalue { ptr, i32 } [[CAUGHTVAL]], 0
 136 // CHECK-NEXT: store ptr [[CAUGHTEXN]], ptr [[CAUGHTEXNVAR]]
 137 // CHECK-NEXT: [[SELECTOR:%.*]] = extractvalue { ptr, i32 } [[CAUGHTVAL]], 1
 138 // CHECK-NEXT: store i32 [[SELECTOR]], ptr [[SELECTORVAR]]
 139 // CHECK-NEXT: call void @__cxa_end_catch()
 140 // CHECK-NEXT: br label
 141 // CHECK:      load ptr, ptr [[CAUGHTEXNVAR]]
 142 // CHECK-NEXT: call ptr @__cxa_begin_catch
 143 // CHECK-NEXT: call void @__cxa_end_catch
 144     catch (...) {
 145     }
 146 // CHECK:      ret i32 0
 147     return 0;
 148   }
 149 }
 150
 151 // Ordering of destructors in a catch handler.
 152 namespace test8 {
 153   struct A { A(const A&); ~A(); };
 154   void bar();
 155
 156   // CHECK-LABEL: define{{.*}} void @_ZN5test83fooEv()
 157   void foo() {
 158     try {
 159       // CHECK:      invoke void @_ZN5test83barEv()
 160       bar();
 161     } catch (A a) {
 162       // CHECK:      call ptr @__cxa_get_exception_ptr
 163       // CHECK-NEXT: invoke void @_ZN5test81AC1ERKS0_(
 164       // CHECK:      call ptr @__cxa_begin_catch
 165       // CHECK-NEXT: call void @_ZN5test81AD1Ev(
 166       // CHECK:      call void @__cxa_end_catch()
 167       // CHECK:      ret void
 168     }
 169   }
 170 }
 171
 172 // Constructor function-try-block must rethrow on fallthrough.
 173 namespace test9 {
 174   void opaque();
 175
 176   struct A { A(); };
 177
 178
 179   // CHECK-LABEL: define{{.*}} void @_ZN5test91AC2Ev(ptr {{[^,]*}} %this) unnamed_addr
 180   // CHECK-SAME:  personality ptr @__gxx_personality_v0
 181   A::A() try {
 182   // CHECK:      invoke void @_ZN5test96opaqueEv()
 183     opaque();
 184   } catch (int x) {
 185   // CHECK:      landingpad { ptr, i32 }
 186   // CHECK-NEXT:   catch ptr @_ZTIi
 187
 188   // CHECK:      call ptr @__cxa_begin_catch
 189   // CHECK:      invoke void @_ZN5test96opaqueEv()
 190   // CHECK:      invoke void @__cxa_rethrow()
 191
 192   // CHECK-LABEL:      define{{.*}} void @_ZN5test91AC1Ev(ptr {{[^,]*}} %this) unnamed_addr
 193   // CHECK:      call void @_ZN5test91AC2Ev
 194   // CHECK-NEXT: ret void
 195     opaque();
 196   }
 197 }
 198
 199 // __cxa_end_catch can throw for some kinds of caught exceptions.
 200 namespace test10 {
 201   void opaque();
 202
 203   struct A { ~A(); };
 204   struct B { int x; };
 205
 206   // CHECK-LABEL: define{{.*}} void @_ZN6test103fooEv()
 207   void foo() {
 208     A a; // force a cleanup context
 209
 210     try {
 211     // CHECK:      invoke void @_ZN6test106opaqueEv()
 212       opaque();
 213     } catch (int i) {
 214     // CHECK:      call ptr @__cxa_begin_catch
 215     // CHECK-NEXT: load i32, ptr
 216     // CHECK-NEXT: store i32
 217     // CHECK-NEXT: call void @__cxa_end_catch() [[NUW:#[0-9]+]]
 218     } catch (B a) {
 219     // CHECK:      call ptr @__cxa_begin_catch
 220     // CHECK-NEXT: call void @llvm.memcpy
 221     // CHECK-NEXT: invoke void @__cxa_end_catch()
 222     } catch (...) {
 223     // CHECK:      call ptr @__cxa_begin_catch
 224     // CHECK-NEXT: invoke void @__cxa_end_catch()
 225     }
 226
 227     // CHECK: call void @_ZN6test101AD1Ev(
 228   }
 229 }
 230
 231 // __cxa_begin_catch returns pointers by value, even when catching by reference
 232 namespace test11 {
 233   void opaque();
 234
 235   // CHECK-LABEL: define{{.*}} void @_ZN6test113fooEv()
 236   void foo() {
 237     try {
 238       // CHECK:      invoke void @_ZN6test116opaqueEv()
 239       opaque();
 240     } catch (int**&p) {
 241       // CHECK:      [[EXN:%.*]] = load ptr, ptr
 242       // CHECK-NEXT: call ptr @__cxa_begin_catch(ptr [[EXN]]) [[NUW]]
 243       // CHECK-NEXT: [[ADJ1:%.*]] = getelementptr i8, ptr [[EXN]], i32 32
 244       // CHECK-NEXT: store ptr [[ADJ1]], ptr [[P:%.*]]
 245       // CHECK-NEXT: call void @__cxa_end_catch() [[NUW]]
 246     }
 247   }
 248
 249   struct A {};
 250
 251   // CHECK-LABEL: define{{.*}} void @_ZN6test113barEv()
 252   void bar() {
 253     try {
 254       // CHECK:      [[EXNSLOT:%.*]] = alloca ptr
 255       // CHECK-NEXT: [[SELECTORSLOT:%.*]] = alloca i32
 256       // CHECK-NEXT: [[P:%.*]] = alloca ptr,
 257       // CHECK-NEXT: [[TMP:%.*]] = alloca ptr
 258       // CHECK-NEXT: invoke void @_ZN6test116opaqueEv()
 259       opaque();
 260     } catch (A*&p) {
 261       // CHECK:      [[EXN:%.*]] = load ptr, ptr [[EXNSLOT]]
 262       // CHECK-NEXT: [[ADJ1:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) [[NUW]]
 263       // CHECK-NEXT: store ptr [[ADJ1]], ptr [[TMP]]
 264       // CHECK-NEXT: store ptr [[TMP]], ptr [[P]]
 265       // CHECK-NEXT: call void @__cxa_end_catch() [[NUW]]
 266     }
 267   }
 268 }
 269
 270 // PR7686
 271 namespace test12 {
 272   struct A { ~A() noexcept(false); };
 273   bool opaque(const A&);
 274
 275   // CHECK-LABEL: define{{.*}} void @_ZN6test124testEv()
 276   void test() {
 277     // CHECK: [[X:%.*]] = alloca [[A:%.*]],
 278     // CHECK: [[EHCLEANUPDEST:%.*]] = alloca i32
 279     // CHECK: [[Y:%.*]] = alloca [[A:%.*]]
 280     // CHECK: [[Z:%.*]] = alloca [[A]]
 281     // CHECK: [[CLEANUPDEST:%.*]] = alloca i32
 282
 283     A x;
 284     // CHECK: invoke noundef zeroext i1 @_ZN6test126opaqueERKNS_1AE(
 285     if (opaque(x)) {
 286       A y;
 287       A z;
 288
 289       // CHECK: invoke void @_ZN6test121AD1Ev(ptr {{[^,]*}} [[Z]])
 290       // CHECK: invoke void @_ZN6test121AD1Ev(ptr {{[^,]*}} [[Y]])
 291       // CHECK-NOT: switch
 292       goto success;
 293     }
 294
 295   success:
 296     bool _ = true;
 297
 298     // CHECK: call void @_ZN6test121AD1Ev(ptr {{[^,]*}} [[X]])
 299     // CHECK-NEXT: ret void
 300   }
 301 }
 302
 303 // Reduced from some TableGen code that was causing a self-host crash.
 304 namespace test13 {
 305   struct A { ~A(); };
 306
 307   void test0(int x) {
 308     try {
 309       switch (x) {
 310       case 0:
 311         break;
 312       case 1:{
 313         A a;
 314         break;
 315       }
 316       default:
 317         return;
 318       }
 319       return;
 320     } catch (int x) {
 321     }
 322     return;
 323   }
 324
 325   void test1(int x) {
 326     A y;
 327     try {
 328       switch (x) {
 329       default: break;
 330       }
 331     } catch (int x) {}
 332   }
 333 }
 334
 335 namespace test14 {
 336   struct A { ~A(); };
 337   struct B { ~B(); };
 338
 339   B b();
 340   void opaque();
 341
 342   void foo() {
 343     A a;
 344     try {
 345       B str = b();
 346       opaque();
 347     } catch (int x) {
 348     }
 349   }
 350 }
 351
 352 // JumpDests shouldn't get confused by scopes that aren't normal cleanups.
 353 namespace test15 {
 354   struct A { ~A(); };
 355
 356   bool opaque(int);
 357
 358   // CHECK-LABEL: define{{.*}} void @_ZN6test153fooEv()
 359   void foo() {
 360     A a;
 361
 362     try {
 363       // CHECK:      [[X:%.*]] = alloca i32
 364       // CHECK:      store i32 10, ptr [[X]]
 365       // CHECK-NEXT: br label
 366       //   -> while.cond
 367       int x = 10;
 368
 369       while (true) {
 370         // CHECK:      load i32, ptr [[X]]
 371         // CHECK-NEXT: [[COND:%.*]] = invoke noundef zeroext i1 @_ZN6test156opaqueEi
 372         // CHECK:      br i1 [[COND]]
 373         if (opaque(x))
 374         // CHECK:      br label
 375           break;
 376
 377         // CHECK:      br label
 378       }
 379       // CHECK:      br label
 380     } catch (int x) { }
 381
 382     // CHECK: call void @_ZN6test151AD1Ev
 383   }
 384 }
 385
 386 namespace test16 {
 387   struct A { A(); ~A() noexcept(false); };
 388   struct B { int x; B(const A &); ~B() noexcept(false); };
 389   void foo();
 390   bool cond();
 391
 392   // CHECK-LABEL: define{{.*}} void @_ZN6test163barEv()
 393   void bar() {
 394     // CHECK:      [[EXN_SAVE:%.*]] = alloca ptr
 395     // CHECK-NEXT: [[EXN_ACTIVE:%.*]] = alloca i1
 396     // CHECK-NEXT: [[TEMP:%.*]] = alloca [[A:%.*]],
 397     // CHECK-NEXT: [[EXNSLOT:%.*]] = alloca ptr
 398     // CHECK-NEXT: [[SELECTORSLOT:%.*]] = alloca i32
 399     // CHECK-NEXT: [[TEMP_ACTIVE:%.*]] = alloca i1
 400
 401     cond() ? throw B(A()) : foo();
 402
 403     // CHECK-NEXT: [[COND:%.*]] = call noundef zeroext i1 @_ZN6test164condEv()
 404     // CHECK-NEXT: store i1 false, ptr [[EXN_ACTIVE]]
 405     // CHECK-NEXT: store i1 false, ptr [[TEMP_ACTIVE]]
 406     // CHECK-NEXT: br i1 [[COND]],
 407
 408     // CHECK:      [[EXN:%.*]] = call ptr @__cxa_allocate_exception(i64 4)
 409     // CHECK-NEXT: store ptr [[EXN]], ptr [[EXN_SAVE]]
 410     // CHECK-NEXT: store i1 true, ptr [[EXN_ACTIVE]]
 411     // CHECK-NEXT: invoke void @_ZN6test161AC1Ev(ptr {{[^,]*}} [[TEMP]])
 412     // CHECK:      store i1 true, ptr [[TEMP_ACTIVE]]
 413     // CHECK-NEXT: invoke void @_ZN6test161BC1ERKNS_1AE(ptr {{[^,]*}} [[EXN]], ptr noundef nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[TEMP]])
 414     // CHECK:      store i1 false, ptr [[EXN_ACTIVE]]
 415     // CHECK-NEXT: invoke void @__cxa_throw(ptr [[EXN]],
 416
 417     // CHECK:      invoke void @_ZN6test163fooEv()
 418     // CHECK:      br label
 419
 420     // CHECK:      invoke void @_ZN6test161AD1Ev(ptr {{[^,]*}} [[TEMP]])
 421     // CHECK:      ret void
 422
 423     // CHECK:      [[T0:%.*]] = load i1, ptr [[EXN_ACTIVE]]
 424     // CHECK-NEXT: br i1 [[T0]]
 425     // CHECK:      [[T1:%.*]] = load ptr, ptr [[EXN_SAVE]]
 426     // CHECK-NEXT: call void @__cxa_free_exception(ptr [[T1]])
 427     // CHECK-NEXT: br label
 428   }
 429 }
 430
 431 namespace test17 {
 432 class BaseException {
 433 private:
 434   int a[4];
 435 public:
 436   BaseException() {};
 437 };
 438
 439 class DerivedException: public BaseException {
 440 };
 441
 442 int foo() {
 443   throw DerivedException();
 444   // The alignment passed to memset is 16 on Darwin.
 445
 446   // CHECK: [[T0:%.*]] = call ptr @__cxa_allocate_exception(i64 16)
 447   // UNALIGNED-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[T0]], i8 0, i64 16, i1 false)
 448   // ALIGNED-NEXT: call void @llvm.memset.p0.i64(ptr align 16 [[T0]], i8 0, i64 16, i1 false)
 449 }
 450 }
 451
 452 // CHECK: attributes [[NUW]] = { nounwind }
 453 // CHECK: attributes [[NR]] = { noreturn }