1 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s 2 3 typedef typeof(sizeof(0)) size_t; 4 5 // This just shouldn't crash. 6 namespace test0 { 7 struct allocator { 8 allocator(); 9 allocator(const allocator&); 10 ~allocator(); 11 }; 12 13 void f(); g(bool b,bool c)14 void g(bool b, bool c) { 15 if (b) { 16 if (!c) 17 throw allocator(); 18 19 return; 20 } 21 f(); 22 } 23 } 24 25 namespace test1 { 26 struct A { A(int); A(int, int); ~A(); void *p; }; 27 a()28 A *a() { 29 // CHECK: define [[A:%.*]]* @_ZN5test11aEv() 30 // CHECK: [[NEW:%.*]] = call noalias i8* @_Znwm(i64 8) 31 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 32 // CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 5) 33 // CHECK: ret [[A]]* [[CAST]] 34 // CHECK: call void @_ZdlPv(i8* [[NEW]]) 35 return new A(5); 36 } 37 b()38 A *b() { 39 // CHECK: define [[A:%.*]]* @_ZN5test11bEv() 40 // CHECK: [[NEW:%.*]] = call noalias i8* @_Znwm(i64 8) 41 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 42 // CHECK-NEXT: [[FOO:%.*]] = invoke i32 @_ZN5test13fooEv() 43 // CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[FOO]]) 44 // CHECK: ret [[A]]* [[CAST]] 45 // CHECK: call void @_ZdlPv(i8* [[NEW]]) 46 extern int foo(); 47 return new A(foo()); 48 } 49 50 struct B { B(); ~B(); operator int(); int x; }; 51 B makeB(); 52 c()53 A *c() { 54 // CHECK: define [[A:%.*]]* @_ZN5test11cEv() 55 // CHECK: [[ACTIVE:%.*]] = alloca i1 56 // CHECK-NEXT: [[NEW:%.*]] = call noalias i8* @_Znwm(i64 8) 57 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]] 58 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 59 // CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]]) 60 // CHECK: [[T1:%.*]] = getelementptr inbounds [[B]]* [[T0]], i32 0, i32 0 61 // CHECK-NEXT: [[T2:%.*]] = load i32* [[T1]], align 4 62 // CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T2]]) 63 // CHECK: store i1 false, i1* [[ACTIVE]] 64 // CHECK-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]]) 65 // CHECK: ret [[A]]* [[CAST]] 66 // CHECK: [[ISACTIVE:%.*]] = load i1* [[ACTIVE]] 67 // CHECK-NEXT: br i1 [[ISACTIVE]] 68 // CHECK: call void @_ZdlPv(i8* [[NEW]]) 69 return new A(B().x); 70 } 71 d()72 A *d() { 73 // CHECK: define [[A:%.*]]* @_ZN5test11dEv() 74 // CHECK: [[ACTIVE:%.*]] = alloca i1 75 // CHECK-NEXT: [[NEW:%.*]] = call noalias i8* @_Znwm(i64 8) 76 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]] 77 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 78 // CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]]) 79 // CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]]) 80 // CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]]) 81 // CHECK: store i1 false, i1* [[ACTIVE]] 82 // CHECK-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]]) 83 // CHECK: ret [[A]]* [[CAST]] 84 // CHECK: [[ISACTIVE:%.*]] = load i1* [[ACTIVE]] 85 // CHECK-NEXT: br i1 [[ISACTIVE]] 86 // CHECK: call void @_ZdlPv(i8* [[NEW]]) 87 return new A(B()); 88 } 89 e()90 A *e() { 91 // CHECK: define [[A:%.*]]* @_ZN5test11eEv() 92 // CHECK: [[ACTIVE:%.*]] = alloca i1 93 // CHECK-NEXT: [[NEW:%.*]] = call noalias i8* @_Znwm(i64 8) 94 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]] 95 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 96 // CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]]) 97 // CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]]) 98 // CHECK: invoke void @_ZN5test11BC1Ev([[B]]* [[T2:%.*]]) 99 // CHECK: [[T3:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T2]]) 100 // CHECK: invoke void @_ZN5test11AC1Eii([[A]]* [[CAST]], i32 [[T1]], i32 [[T3]]) 101 // CHECK: store i1 false, i1* [[ACTIVE]] 102 // CHECK-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]]) 103 // CHECK: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]]) 104 // CHECK: ret [[A]]* [[CAST]] 105 // CHECK: [[ISACTIVE:%.*]] = load i1* [[ACTIVE]] 106 // CHECK-NEXT: br i1 [[ISACTIVE]] 107 // CHECK: call void @_ZdlPv(i8* [[NEW]]) 108 return new A(B(), B()); 109 } f()110 A *f() { 111 return new A(makeB().x); 112 } g()113 A *g() { 114 return new A(makeB()); 115 } h()116 A *h() { 117 return new A(makeB(), makeB()); 118 } 119 i()120 A *i() { 121 // CHECK: define [[A:%.*]]* @_ZN5test11iEv() 122 // CHECK: [[X:%.*]] = alloca [[A]]*, align 8 123 // CHECK: [[ACTIVE:%.*]] = alloca i1 124 // CHECK: [[NEW:%.*]] = call noalias i8* @_Znwm(i64 8) 125 // CHECK-NEXT: store i1 true, i1* [[ACTIVE]] 126 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 127 // CHECK-NEXT: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret [[T0:%.*]]) 128 // CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]]) 129 // CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]]) 130 // CHECK: store i1 false, i1* [[ACTIVE]] 131 // CHECK-NEXT: store [[A]]* [[CAST]], [[A]]** [[X]], align 8 132 // CHECK: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret [[T2:%.*]]) 133 // CHECK: [[RET:%.*]] = load [[A]]** [[X]], align 8 134 // CHECK: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]]) 135 // CHECK: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]]) 136 // CHECK: ret [[A]]* [[RET]] 137 // CHECK: [[ISACTIVE:%.*]] = load i1* [[ACTIVE]] 138 // CHECK-NEXT: br i1 [[ISACTIVE]] 139 // CHECK: call void @_ZdlPv(i8* [[NEW]]) 140 A *x; 141 return (x = new A(makeB()), makeB(), x); 142 } 143 } 144 145 namespace test2 { 146 struct A { 147 A(int); A(int, int); ~A(); 148 void *p; 149 void *operator new(size_t); 150 void operator delete(void*, size_t); 151 }; 152 a()153 A *a() { 154 // CHECK: define [[A:%.*]]* @_ZN5test21aEv() 155 // CHECK: [[NEW:%.*]] = call i8* @_ZN5test21AnwEm(i64 8) 156 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 157 // CHECK-NEXT: invoke void @_ZN5test21AC1Ei([[A]]* [[CAST]], i32 5) 158 // CHECK: ret [[A]]* [[CAST]] 159 // CHECK: invoke void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8) 160 // CHECK: call void @_ZSt9terminatev() 161 return new A(5); 162 } 163 } 164 165 namespace test3 { 166 struct A { 167 A(int); A(int, int); A(const A&); ~A(); 168 void *p; 169 void *operator new(size_t, void*, double); 170 void operator delete(void*, void*, double); 171 }; 172 173 void *foo(); 174 double bar(); 175 A makeA(), *makeAPtr(); 176 a()177 A *a() { 178 // CHECK: define [[A:%.*]]* @_ZN5test31aEv() 179 // CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv() 180 // CHECK: [[BAR:%.*]] = call double @_ZN5test33barEv() 181 // CHECK: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[BAR]]) 182 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 183 // CHECK-NEXT: invoke void @_ZN5test31AC1Ei([[A]]* [[CAST]], i32 5) 184 // CHECK: ret [[A]]* [[CAST]] 185 // CHECK: invoke void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]]) 186 // CHECK: call void @_ZSt9terminatev() 187 return new(foo(),bar()) A(5); 188 } 189 190 // rdar://problem/8439196 b(bool cond)191 A *b(bool cond) { 192 193 // CHECK: define [[A:%.*]]* @_ZN5test31bEb(i1 zeroext 194 // CHECK: [[SAVED0:%.*]] = alloca i8* 195 // CHECK-NEXT: [[SAVED1:%.*]] = alloca i8* 196 // CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1 197 198 // CHECK: [[COND:%.*]] = trunc i8 {{.*}} to i1 199 // CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]] 200 // CHECK-NEXT: br i1 [[COND]] 201 return (cond ? 202 203 // CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv() 204 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[CONST:.*]]) 205 // CHECK-NEXT: store i8* [[NEW]], i8** [[SAVED0]] 206 // CHECK-NEXT: store i8* [[FOO]], i8** [[SAVED1]] 207 // CHECK-NEXT: store i1 true, i1* [[CLEANUPACTIVE]] 208 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 209 // CHECK-NEXT: invoke void @_ZN5test35makeAEv([[A]]* sret [[CAST]]) 210 // CHECK: br label 211 // -> cond.end 212 new(foo(),10.0) A(makeA()) : 213 214 // CHECK: [[MAKE:%.*]] = call [[A]]* @_ZN5test38makeAPtrEv() 215 // CHECK: br label 216 // -> cond.end 217 makeAPtr()); 218 219 // cond.end: 220 // CHECK: [[RESULT:%.*]] = phi [[A]]* {{.*}}[[CAST]]{{.*}}[[MAKE]] 221 // CHECK: ret [[A]]* [[RESULT]] 222 223 // in the EH path: 224 // CHECK: [[ISACTIVE:%.*]] = load i1* [[CLEANUPACTIVE]] 225 // CHECK-NEXT: br i1 [[ISACTIVE]] 226 // CHECK: [[V0:%.*]] = load i8** [[SAVED0]] 227 // CHECK-NEXT: [[V1:%.*]] = load i8** [[SAVED1]] 228 // CHECK-NEXT: invoke void @_ZN5test31AdlEPvS1_d(i8* [[V0]], i8* [[V1]], double [[CONST]]) 229 } 230 } 231 232 namespace test4 { 233 struct A { 234 A(int); A(int, int); ~A(); 235 void *p; 236 void *operator new(size_t, void*, void*); 237 void operator delete(void*, size_t, void*, void*); // not a match 238 }; 239 a()240 A *a() { 241 // CHECK: define [[A:%.*]]* @_ZN5test41aEv() 242 // CHECK: [[FOO:%.*]] = call i8* @_ZN5test43fooEv() 243 // CHECK-NEXT: [[BAR:%.*]] = call i8* @_ZN5test43barEv() 244 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test41AnwEmPvS1_(i64 8, i8* [[FOO]], i8* [[BAR]]) 245 // CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]* 246 // CHECK-NEXT: call void @_ZN5test41AC1Ei([[A]]* [[CAST]], i32 5) 247 // CHECK-NEXT: ret [[A]]* [[CAST]] 248 extern void *foo(), *bar(); 249 250 return new(foo(),bar()) A(5); 251 } 252 } 253 254 // PR7908 255 namespace test5 { 256 struct T { T(); ~T(); }; 257 258 struct A { 259 A(const A &x, const T &t = T()); 260 ~A(); 261 }; 262 263 void foo(); 264 265 // CHECK: define void @_ZN5test54testEv() 266 // CHECK: [[EXNSLOT:%.*]] = alloca i8* 267 // CHECK-NEXT: [[SELECTORSLOT:%.*]] = alloca i32 268 // CHECK-NEXT: [[A:%.*]] = alloca [[A_T:%.*]], align 1 269 // CHECK-NEXT: [[T:%.*]] = alloca [[T_T:%.*]], align 1 270 // CHECK-NEXT: invoke void @_ZN5test53fooEv() 271 // CHECK: [[EXN:%.*]] = load i8** [[EXNSLOT]] 272 // CHECK-NEXT: [[ADJ:%.*]] = call i8* @__cxa_get_exception_ptr(i8* [[EXN]]) 273 // CHECK-NEXT: [[SRC:%.*]] = bitcast i8* [[ADJ]] to [[A_T]]* 274 // CHECK-NEXT: invoke void @_ZN5test51TC1Ev([[T_T]]* [[T]]) 275 // CHECK: invoke void @_ZN5test51AC1ERKS0_RKNS_1TE([[A_T]]* [[A]], [[A_T]]* [[SRC]], [[T_T]]* [[T]]) 276 // CHECK: invoke void @_ZN5test51TD1Ev([[T_T]]* [[T]]) 277 // CHECK: call i8* @__cxa_begin_catch(i8* [[EXN]]) nounwind 278 // CHECK-NEXT: invoke void @_ZN5test51AD1Ev([[A_T]]* [[A]]) 279 // CHECK: call void @__cxa_end_catch() test()280 void test() { 281 try { 282 foo(); 283 } catch (A a) { 284 } 285 } 286 } 287 288 // PR9303: invalid assert on this 289 namespace test6 { 290 bool cond(); test()291 void test() { 292 try { 293 lbl: 294 if (cond()) goto lbl; 295 } catch (...) { 296 } 297 } 298 } 299 300 // PR9298 301 namespace test7 { 302 struct A { A(); ~A(); }; 303 struct B { 304 // The throw() operator means that a bad allocation is signalled 305 // with a null return, which means that the initializer is 306 // evaluated conditionally. 307 static void *operator new(size_t size) throw(); 308 B(const A&, B*); 309 ~B(); 310 }; 311 test()312 B *test() { 313 // CHECK: define [[B:%.*]]* @_ZN5test74testEv() 314 // CHECK: [[OUTER_NEW:%.*]] = alloca i1 315 // CHECK-NEXT: alloca [[A:%.*]], 316 // CHECK-NEXT: alloca i8* 317 // CHECK-NEXT: alloca i32 318 // CHECK-NEXT: [[OUTER_A:%.*]] = alloca i1 319 // CHECK-NEXT: alloca i8* 320 // CHECK-NEXT: [[INNER_NEW:%.*]] = alloca i1 321 // CHECK-NEXT: alloca [[A]] 322 // CHECK-NEXT: [[INNER_A:%.*]] = alloca i1 323 324 // Allocate the outer object. 325 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm( 326 // CHECK-NEXT: icmp eq i8* [[NEW]], null 327 328 // These stores, emitted before the outermost conditional branch, 329 // deactivate the temporary cleanups. 330 // CHECK-NEXT: store i1 false, i1* [[OUTER_NEW]] 331 // CHECK-NEXT: store i1 false, i1* [[OUTER_A]] 332 // CHECK-NEXT: store i1 false, i1* [[INNER_NEW]] 333 // CHECK-NEXT: store i1 false, i1* [[INNER_A]] 334 // CHECK-NEXT: br i1 335 336 // We passed the first null check; activate that cleanup and continue. 337 // CHECK: store i1 true, i1* [[OUTER_NEW]] 338 // CHECK-NEXT: bitcast 339 340 // Create the first A temporary and activate that cleanup. 341 // CHECK-NEXT: invoke void @_ZN5test71AC1Ev( 342 // CHECK: store i1 true, i1* [[OUTER_A]] 343 344 // Allocate the inner object. 345 // CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm( 346 // CHECK-NEXT: icmp eq i8* [[NEW]], null 347 // CHECK-NEXT: br i1 348 349 // We passed the second null check; save that pointer, activate 350 // that cleanup, and continue. 351 // CHECK: store i8* [[NEW]] 352 // CHECK-NEXT: store i1 true, i1* [[INNER_NEW]] 353 // CHECK-NEXT: bitcast 354 355 // Build the second A temporary and activate that cleanup. 356 // CHECK-NEXT: invoke void @_ZN5test71AC1Ev( 357 // CHECK: store i1 true, i1* [[INNER_A]] 358 359 // Build the inner B object and deactivate the inner delete cleanup. 360 // CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_( 361 // CHECK: store i1 false, i1* [[INNER_NEW]] 362 // CHECK: phi 363 364 // Build the outer B object and deactivate the outer delete cleanup. 365 // CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_( 366 // CHECK: store i1 false, i1* [[OUTER_NEW]] 367 // CHECK: phi 368 369 // Destroy the inner A object. 370 // CHECK-NEXT: load i1* [[INNER_A]] 371 // CHECK-NEXT: br i1 372 // CHECK: invoke void @_ZN5test71AD1Ev( 373 374 // Destroy the outer A object. 375 // CHECK: load i1* [[OUTER_A]] 376 // CHECK-NEXT: br i1 377 // CHECK: invoke void @_ZN5test71AD1Ev( 378 379 return new B(A(), new B(A(), 0)); 380 } 381 } 382 383 // Just don't crash. 384 namespace test8 { 385 struct A { 386 // Having both of these is required to trigger the assert we're 387 // trying to avoid. 388 A(const A&); 389 A&operator=(const A&); 390 391 ~A(); 392 }; 393 394 A makeA(); test()395 void test() { 396 throw makeA(); 397 } 398 // CHECK: define void @_ZN5test84testEv 399 } 400 401 // Make sure we generate the correct code for the delete[] call which 402 // happens if A::A() throws. (We were previously calling delete[] on 403 // a pointer to the first array element, not the pointer returned by new[].) 404 // PR10870 405 namespace test9 { 406 struct A { 407 A(); 408 ~A(); 409 }; test()410 A* test() { 411 return new A[10]; 412 } 413 // CHECK: define {{%.*}}* @_ZN5test94testEv 414 // CHECK: [[TEST9_NEW:%.*]] = call noalias i8* @_Znam 415 // CHECK: call void @_ZdaPv(i8* [[TEST9_NEW]]) 416 } 417 418 // In a destructor with a function-try-block, a return statement in a 419 // catch handler behaves differently from running off the end of the 420 // catch handler. PR13102. 421 namespace test10 { 422 extern void cleanup(); 423 extern bool suppress; 424 425 struct A { ~A(); }; ~A()426 A::~A() try { cleanup(); } catch (...) { return; } 427 // CHECK: define void @_ZN6test101AD1Ev( 428 // CHECK: invoke void @_ZN6test107cleanupEv() 429 // CHECK-NOT: rethrow 430 // CHECK: ret void 431 432 struct B { ~B(); }; ~B()433 B::~B() try { cleanup(); } catch (...) {} 434 // CHECK: define void @_ZN6test101BD1Ev( 435 // CHECK: invoke void @_ZN6test107cleanupEv() 436 // CHECK: call i8* @__cxa_begin_catch 437 // CHECK-NEXT: invoke void @__cxa_rethrow() 438 // CHECK: unreachable 439 440 struct C { ~C(); }; ~C()441 C::~C() try { cleanup(); } catch (...) { if (suppress) return; } 442 // CHECK: define void @_ZN6test101CD1Ev( 443 // CHECK: invoke void @_ZN6test107cleanupEv() 444 // CHECK: call i8* @__cxa_begin_catch 445 // CHECK-NEXT: load i8* @_ZN6test108suppressE, align 1 446 // CHECK-NEXT: trunc 447 // CHECK-NEXT: br i1 448 // CHECK: call void @__cxa_end_catch() 449 // CHECK-NEXT: br label 450 // CHECK: invoke void @__cxa_rethrow() 451 // CHECK: unreachable 452 } 453