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 4 typedef __typeof(sizeof(0)) size_t; 5 6 // Declare the reserved global placement new. 7 void *operator new(size_t, void*); 8 9 // This just shouldn't crash. 10 namespace test0 { 11 struct allocator { 12 allocator(); 13 allocator(const allocator&); 14 ~allocator(); 15 }; 16 17 void f(); g(bool b,bool c)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 29 namespace test1 { 30 struct A { A(int); A(int, int); ~A(); void *p; }; 31 a()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 b()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 c()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* %0) [[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 d()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 e()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 } f()132 A *f() { 133 return new A(makeB().x); 134 } g()135 A *g() { 136 return new A(makeB()); 137 } h()138 A *h() { 139 return new A(makeB(), makeB()); 140 } 141 i()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 172 namespace 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 a()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 195 namespace 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 a()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 b(bool cond)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 267 namespace 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 a()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 290 namespace 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() test()319 void test() { 320 try { 321 foo(); 322 } catch (A a) { 323 } 324 } 325 } 326 327 // PR9303: invalid assert on this 328 namespace test6 { 329 bool cond(); test()330 void test() { 331 try { 332 lbl: 333 if (cond()) goto lbl; 334 } catch (...) { 335 } 336 } 337 } 338 339 // PR9298 340 namespace 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 test()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. 428 namespace 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(); test()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 449 namespace test9 { 450 struct A { 451 A(); 452 ~A(); 453 }; test()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. 465 namespace test10 { 466 extern void cleanup(); 467 extern bool suppress; 468 469 struct A { ~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(); }; ~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(); }; ~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 504 namespace test11 { 505 struct A { 506 A(); ~Atest11::A507 ~A() {} 508 }; 509 510 struct C { 511 A single; 512 A array[2][3]; 513 514 C(); 515 }; 516 C()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 578 namespace test12 { 579 struct A { 580 void operator delete(void *, void *); 581 A(); 582 }; 583 test(void * ptr)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