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