1 ; RUN: opt -objc-arc -S < %s | FileCheck %s 2 3 target datalayout = "e-p:64:64:64" 4 5 declare i8* @objc_retain(i8*) 6 declare void @objc_release(i8*) 7 declare i8* @objc_autorelease(i8*) 8 declare void @objc_autoreleasePoolPop(i8*) 9 declare void @objc_autoreleasePoolPush() 10 declare i8* @objc_retainBlock(i8*) 11 12 declare i8* @objc_retainedObject(i8*) 13 declare i8* @objc_unretainedObject(i8*) 14 declare i8* @objc_unretainedPointer(i8*) 15 16 declare void @use_pointer(i8*) 17 declare void @callee() 18 declare void @callee_fnptr(void ()*) 19 declare void @invokee() 20 declare i8* @returner() 21 22 declare void @llvm.dbg.value(metadata, i64, metadata) 23 24 declare i8* @objc_msgSend(i8*, i8*, ...) 25 26 ; Simple retain+release pair deletion, with some intervening control 27 ; flow and harmless instructions. 28 29 ; CHECK: define void @test0( 30 ; CHECK-NOT: @objc_ 31 ; CHECK: } 32 define void @test0(i32* %x, i1 %p) nounwind { 33 entry: 34 %a = bitcast i32* %x to i8* 35 %0 = call i8* @objc_retain(i8* %a) nounwind 36 br i1 %p, label %t, label %f 37 38 t: 39 store i8 3, i8* %a 40 %b = bitcast i32* %x to float* 41 store float 2.0, float* %b 42 br label %return 43 44 f: 45 store i32 7, i32* %x 46 br label %return 47 48 return: 49 %c = bitcast i32* %x to i8* 50 call void @objc_release(i8* %c) nounwind 51 ret void 52 } 53 54 ; Like test0 but the release isn't always executed when the retain is, 55 ; so the optimization is not safe. 56 57 ; TODO: Make the objc_release's argument be %0. 58 59 ; CHECK: define void @test1( 60 ; CHECK: @objc_retain(i8* %a) 61 ; CHECK: @objc_release 62 ; CHECK: } 63 define void @test1(i32* %x, i1 %p, i1 %q) nounwind { 64 entry: 65 %a = bitcast i32* %x to i8* 66 %0 = call i8* @objc_retain(i8* %a) nounwind 67 br i1 %p, label %t, label %f 68 69 t: 70 store i8 3, i8* %a 71 %b = bitcast i32* %x to float* 72 store float 2.0, float* %b 73 br label %return 74 75 f: 76 store i32 7, i32* %x 77 call void @callee() 78 br i1 %q, label %return, label %alt_return 79 80 return: 81 %c = bitcast i32* %x to i8* 82 call void @objc_release(i8* %c) nounwind 83 ret void 84 85 alt_return: 86 ret void 87 } 88 89 ; Like test0 but the pointer is passed to an intervening call, 90 ; so the optimization is not safe. 91 92 ; CHECK: define void @test2( 93 ; CHECK: @objc_retain(i8* %a) 94 ; CHECK: @objc_release 95 ; CHECK: } 96 define void @test2(i32* %x, i1 %p) nounwind { 97 entry: 98 %a = bitcast i32* %x to i8* 99 %0 = call i8* @objc_retain(i8* %a) nounwind 100 br i1 %p, label %t, label %f 101 102 t: 103 store i8 3, i8* %a 104 %b = bitcast i32* %x to float* 105 store float 2.0, float* %b 106 br label %return 107 108 f: 109 store i32 7, i32* %x 110 call void @use_pointer(i8* %0) 111 %d = bitcast i32* %x to float* 112 store float 3.0, float* %d 113 br label %return 114 115 return: 116 %c = bitcast i32* %x to i8* 117 call void @objc_release(i8* %c) nounwind 118 ret void 119 } 120 121 ; Like test0 but the release is in a loop, 122 ; so the optimization is not safe. 123 124 ; TODO: For now, assume this can't happen. 125 126 ; CHECK: define void @test3( 127 ; TODO: @objc_retain(i8* %a) 128 ; TODO: @objc_release 129 ; CHECK: } 130 define void @test3(i32* %x, i1* %q) nounwind { 131 entry: 132 %a = bitcast i32* %x to i8* 133 %0 = call i8* @objc_retain(i8* %a) nounwind 134 br label %loop 135 136 loop: 137 %c = bitcast i32* %x to i8* 138 call void @objc_release(i8* %c) nounwind 139 %j = volatile load i1* %q 140 br i1 %j, label %loop, label %return 141 142 return: 143 ret void 144 } 145 146 ; TODO: For now, assume this can't happen. 147 148 ; Like test0 but the retain is in a loop, 149 ; so the optimization is not safe. 150 151 ; CHECK: define void @test4( 152 ; TODO: @objc_retain(i8* %a) 153 ; TODO: @objc_release 154 ; CHECK: } 155 define void @test4(i32* %x, i1* %q) nounwind { 156 entry: 157 br label %loop 158 159 loop: 160 %a = bitcast i32* %x to i8* 161 %0 = call i8* @objc_retain(i8* %a) nounwind 162 %j = volatile load i1* %q 163 br i1 %j, label %loop, label %return 164 165 return: 166 %c = bitcast i32* %x to i8* 167 call void @objc_release(i8* %c) nounwind 168 ret void 169 } 170 171 ; Like test0 but the pointer is conditionally passed to an intervening call, 172 ; so the optimization is not safe. 173 174 ; CHECK: define void @test5( 175 ; CHECK: @objc_retain(i8* 176 ; CHECK: @objc_release 177 ; CHECK: } 178 define void @test5(i32* %x, i1 %q, i8* %y) nounwind { 179 entry: 180 %a = bitcast i32* %x to i8* 181 %0 = call i8* @objc_retain(i8* %a) nounwind 182 %s = select i1 %q, i8* %y, i8* %0 183 call void @use_pointer(i8* %s) 184 store i32 7, i32* %x 185 %c = bitcast i32* %x to i8* 186 call void @objc_release(i8* %c) nounwind 187 ret void 188 } 189 190 ; retain+release pair deletion, where the release happens on two different 191 ; flow paths. 192 193 ; CHECK: define void @test6( 194 ; CHECK-NOT: @objc_ 195 ; CHECK: } 196 define void @test6(i32* %x, i1 %p) nounwind { 197 entry: 198 %a = bitcast i32* %x to i8* 199 %0 = call i8* @objc_retain(i8* %a) nounwind 200 br i1 %p, label %t, label %f 201 202 t: 203 store i8 3, i8* %a 204 %b = bitcast i32* %x to float* 205 store float 2.0, float* %b 206 %ct = bitcast i32* %x to i8* 207 call void @objc_release(i8* %ct) nounwind 208 br label %return 209 210 f: 211 store i32 7, i32* %x 212 call void @callee() 213 %cf = bitcast i32* %x to i8* 214 call void @objc_release(i8* %cf) nounwind 215 br label %return 216 217 return: 218 ret void 219 } 220 221 ; retain+release pair deletion, where the retain happens on two different 222 ; flow paths. 223 224 ; CHECK: define void @test7( 225 ; CHECK-NOT: @objc_ 226 ; CHECK: } 227 define void @test7(i32* %x, i1 %p) nounwind { 228 entry: 229 %a = bitcast i32* %x to i8* 230 br i1 %p, label %t, label %f 231 232 t: 233 %0 = call i8* @objc_retain(i8* %a) nounwind 234 store i8 3, i8* %a 235 %b = bitcast i32* %x to float* 236 store float 2.0, float* %b 237 br label %return 238 239 f: 240 %1 = call i8* @objc_retain(i8* %a) nounwind 241 store i32 7, i32* %x 242 call void @callee() 243 br label %return 244 245 return: 246 %c = bitcast i32* %x to i8* 247 call void @objc_release(i8* %c) nounwind 248 ret void 249 } 250 251 ; Like test7, but there's a retain/retainBlock mismatch. Don't delete! 252 253 ; CHECK: define void @test7b 254 ; CHECK: t: 255 ; CHECK: call i8* @objc_retainBlock 256 ; CHECK: f: 257 ; CHECK: call i8* @objc_retain 258 ; CHECK: return: 259 ; CHECK: call void @objc_release 260 ; CHECK: } 261 define void @test7b(i32* %x, i1 %p) nounwind { 262 entry: 263 %a = bitcast i32* %x to i8* 264 br i1 %p, label %t, label %f 265 266 t: 267 %0 = call i8* @objc_retainBlock(i8* %a) nounwind 268 store i8 3, i8* %a 269 %b = bitcast i32* %x to float* 270 store float 2.0, float* %b 271 br label %return 272 273 f: 274 %1 = call i8* @objc_retain(i8* %a) nounwind 275 store i32 7, i32* %x 276 call void @callee() 277 br label %return 278 279 return: 280 %c = bitcast i32* %x to i8* 281 call void @objc_release(i8* %c) nounwind 282 ret void 283 } 284 285 ; retain+release pair deletion, where the retain and release both happen on 286 ; different flow paths. Wild! 287 288 ; CHECK: define void @test8( 289 ; CHECK-NOT: @objc_ 290 ; CHECK: } 291 define void @test8(i32* %x, i1 %p, i1 %q) nounwind { 292 entry: 293 %a = bitcast i32* %x to i8* 294 br i1 %p, label %t, label %f 295 296 t: 297 %0 = call i8* @objc_retain(i8* %a) nounwind 298 store i8 3, i8* %a 299 %b = bitcast i32* %x to float* 300 store float 2.0, float* %b 301 br label %mid 302 303 f: 304 %1 = call i8* @objc_retain(i8* %a) nounwind 305 store i32 7, i32* %x 306 br label %mid 307 308 mid: 309 br i1 %q, label %u, label %g 310 311 u: 312 call void @callee() 313 %cu = bitcast i32* %x to i8* 314 call void @objc_release(i8* %cu) nounwind 315 br label %return 316 317 g: 318 %cg = bitcast i32* %x to i8* 319 call void @objc_release(i8* %cg) nounwind 320 br label %return 321 322 return: 323 ret void 324 } 325 326 ; Trivial retain+release pair deletion. 327 328 ; CHECK: define void @test9( 329 ; CHECK-NOT: @objc_ 330 ; CHECK: } 331 define void @test9(i8* %x) nounwind { 332 entry: 333 %0 = call i8* @objc_retain(i8* %x) nounwind 334 call void @objc_release(i8* %0) nounwind 335 ret void 336 } 337 338 ; Retain+release pair, but on an unknown pointer relationship. Don't delete! 339 340 ; CHECK: define void @test9b 341 ; CHECK: @objc_retain(i8* %x) 342 ; CHECK: @objc_release(i8* %s) 343 ; CHECK: } 344 define void @test9b(i8* %x, i1 %j, i8* %p) nounwind { 345 entry: 346 %0 = call i8* @objc_retain(i8* %x) nounwind 347 %s = select i1 %j, i8* %x, i8* %p 348 call void @objc_release(i8* %s) nounwind 349 ret void 350 } 351 352 ; Trivial retain+release pair with intervening calls - don't delete! 353 354 ; CHECK: define void @test10( 355 ; CHECK: @objc_retain(i8* %x) 356 ; CHECK: @use_pointer 357 ; CHECK: @objc_release 358 ; CHECK: } 359 define void @test10(i8* %x) nounwind { 360 entry: 361 %0 = call i8* @objc_retain(i8* %x) nounwind 362 call void @use_pointer(i8* %x) 363 call void @use_pointer(i8* %x) 364 call void @objc_release(i8* %0) nounwind 365 ret void 366 } 367 368 ; Trivial retain+autoreleaserelease pair. Don't delete! 369 ; Also, add a tail keyword, since objc_retain can never be passed 370 ; a stack argument. 371 372 ; CHECK: define void @test11( 373 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind 374 ; CHECK: tail call i8* @objc_autorelease(i8* %0) nounwind 375 ; CHECK: } 376 define void @test11(i8* %x) nounwind { 377 entry: 378 %0 = call i8* @objc_retain(i8* %x) nounwind 379 call i8* @objc_autorelease(i8* %0) nounwind 380 call void @use_pointer(i8* %x) 381 ret void 382 } 383 384 ; Same as test11 but with no use_pointer call. Delete the pair! 385 386 ; CHECK: define void @test11a( 387 ; CHECK: entry: 388 ; CHECK-NEXT: ret void 389 ; CHECK: } 390 define void @test11a(i8* %x) nounwind { 391 entry: 392 %0 = call i8* @objc_retain(i8* %x) nounwind 393 call i8* @objc_autorelease(i8* %0) nounwind 394 ret void 395 } 396 397 ; Same as test11 but the value is returned. Do an RV optimization. 398 399 ; CHECK: define i8* @test11b( 400 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind 401 ; CHECK: tail call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind 402 ; CHECK: } 403 define i8* @test11b(i8* %x) nounwind { 404 entry: 405 %0 = call i8* @objc_retain(i8* %x) nounwind 406 call i8* @objc_autorelease(i8* %0) nounwind 407 ret i8* %x 408 } 409 410 ; Trivial retain,release pair with intervening call, but it's dominated 411 ; by another retain - delete! 412 413 ; CHECK: define void @test12( 414 ; CHECK-NEXT: entry: 415 ; CHECK-NEXT: @objc_retain(i8* %x) 416 ; CHECK-NOT: @objc_ 417 ; CHECK: } 418 define void @test12(i8* %x, i64 %n) { 419 entry: 420 call i8* @objc_retain(i8* %x) nounwind 421 call i8* @objc_retain(i8* %x) nounwind 422 call void @use_pointer(i8* %x) 423 call void @use_pointer(i8* %x) 424 call void @objc_release(i8* %x) nounwind 425 ret void 426 } 427 428 ; Trivial retain,autorelease pair. Don't delete! 429 430 ; CHECK: define void @test13( 431 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind 432 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind 433 ; CHECK: @use_pointer(i8* %x) 434 ; CHECK: tail call i8* @objc_autorelease(i8* %x) nounwind 435 ; CHECK: } 436 define void @test13(i8* %x, i64 %n) { 437 entry: 438 call i8* @objc_retain(i8* %x) nounwind 439 call i8* @objc_retain(i8* %x) nounwind 440 call void @use_pointer(i8* %x) 441 call i8* @objc_autorelease(i8* %x) nounwind 442 ret void 443 } 444 445 ; Delete the retain+release pair. 446 447 ; CHECK: define void @test13b 448 ; CHECK-NEXT: entry: 449 ; CHECK-NEXT: @objc_retain(i8* %x) 450 ; CHECK-NEXT: @use_pointer 451 ; CHECK-NEXT: @use_pointer 452 ; CHECK-NEXT: ret void 453 define void @test13b(i8* %x, i64 %n) { 454 entry: 455 call i8* @objc_retain(i8* %x) nounwind 456 call i8* @objc_retain(i8* %x) nounwind 457 call void @use_pointer(i8* %x) 458 call void @use_pointer(i8* %x) 459 call void @objc_release(i8* %x) nounwind 460 ret void 461 } 462 463 ; Don't delete the retain+release pair because there's an 464 ; autoreleasePoolPop in the way. 465 466 ; CHECK: define void @test13c 467 ; CHECK: @objc_retain(i8* %x) 468 ; CHECK: @objc_autoreleasePoolPop 469 ; CHECK: @objc_retain(i8* %x) 470 ; CHECK: @use_pointer 471 ; CHECK: @objc_release 472 ; CHECK: } 473 define void @test13c(i8* %x, i64 %n) { 474 entry: 475 call i8* @objc_retain(i8* %x) nounwind 476 call void @objc_autoreleasePoolPop(i8* undef) 477 call i8* @objc_retain(i8* %x) nounwind 478 call void @use_pointer(i8* %x) 479 call void @use_pointer(i8* %x) 480 call void @objc_release(i8* %x) nounwind 481 ret void 482 } 483 484 ; Like test13c, but there's an autoreleasePoolPush in the way, but that 485 ; doesn't matter. 486 487 ; CHECK: define void @test13d 488 ; CHECK-NEXT: entry: 489 ; CHECK-NEXT: @objc_retain(i8* %x) 490 ; CHECK-NEXT: @objc_autoreleasePoolPush 491 ; CHECK-NEXT: @use_pointer 492 ; CHECK-NEXT: @use_pointer 493 ; CHECK-NEXT: ret void 494 define void @test13d(i8* %x, i64 %n) { 495 entry: 496 call i8* @objc_retain(i8* %x) nounwind 497 call void @objc_autoreleasePoolPush() 498 call i8* @objc_retain(i8* %x) nounwind 499 call void @use_pointer(i8* %x) 500 call void @use_pointer(i8* %x) 501 call void @objc_release(i8* %x) nounwind 502 ret void 503 } 504 505 ; Trivial retain,release pair with intervening call, but it's post-dominated 506 ; by another release - delete! 507 508 ; CHECK: define void @test14( 509 ; CHECK-NEXT: entry: 510 ; CHECK-NEXT: @use_pointer 511 ; CHECK-NEXT: @use_pointer 512 ; CHECK-NEXT: @objc_release 513 ; CHECK-NEXT: ret void 514 ; CHECK-NEXT: } 515 define void @test14(i8* %x, i64 %n) { 516 entry: 517 call i8* @objc_retain(i8* %x) nounwind 518 call void @use_pointer(i8* %x) 519 call void @use_pointer(i8* %x) 520 call void @objc_release(i8* %x) nounwind 521 call void @objc_release(i8* %x) nounwind 522 ret void 523 } 524 525 ; Trivial retain,autorelease pair with intervening call, but it's post-dominated 526 ; by another release. Don't delete anything. 527 528 ; CHECK: define void @test15( 529 ; CHECK-NEXT: entry: 530 ; CHECK-NEXT: @objc_retain(i8* %x) 531 ; CHECK-NEXT: @use_pointer 532 ; CHECK-NEXT: @objc_autorelease(i8* %x) 533 ; CHECK-NEXT: @objc_release 534 ; CHECK-NEXT: ret void 535 ; CHECK-NEXT: } 536 define void @test15(i8* %x, i64 %n) { 537 entry: 538 call i8* @objc_retain(i8* %x) nounwind 539 call void @use_pointer(i8* %x) 540 call i8* @objc_autorelease(i8* %x) nounwind 541 call void @objc_release(i8* %x) nounwind 542 ret void 543 } 544 545 ; Trivial retain,autorelease pair, post-dominated 546 ; by another release. Delete the retain and release. 547 548 ; CHECK: define void @test15b 549 ; CHECK-NEXT: entry: 550 ; CHECK-NEXT: @objc_autorelease 551 ; CHECK-NEXT: ret void 552 ; CHECK-NEXT: } 553 define void @test15b(i8* %x, i64 %n) { 554 entry: 555 call i8* @objc_retain(i8* %x) nounwind 556 call i8* @objc_autorelease(i8* %x) nounwind 557 call void @objc_release(i8* %x) nounwind 558 ret void 559 } 560 561 ; Retain+release pairs in diamonds, all dominated by a retain. 562 563 ; CHECK: define void @test16( 564 ; CHECK: @objc_retain(i8* %x) 565 ; CHECK-NOT: @objc 566 ; CHECK: } 567 define void @test16(i1 %a, i1 %b, i8* %x) { 568 entry: 569 call i8* @objc_retain(i8* %x) nounwind 570 br i1 %a, label %red, label %orange 571 572 red: 573 call i8* @objc_retain(i8* %x) nounwind 574 br label %yellow 575 576 orange: 577 call i8* @objc_retain(i8* %x) nounwind 578 br label %yellow 579 580 yellow: 581 call void @use_pointer(i8* %x) 582 call void @use_pointer(i8* %x) 583 br i1 %b, label %green, label %blue 584 585 green: 586 call void @objc_release(i8* %x) nounwind 587 br label %purple 588 589 blue: 590 call void @objc_release(i8* %x) nounwind 591 br label %purple 592 593 purple: 594 ret void 595 } 596 597 ; Retain+release pairs in diamonds, all post-dominated by a release. 598 599 ; CHECK: define void @test17( 600 ; CHECK-NOT: @objc_ 601 ; CHECK: purple: 602 ; CHECK: @objc_release 603 ; CHECK: } 604 define void @test17(i1 %a, i1 %b, i8* %x) { 605 entry: 606 br i1 %a, label %red, label %orange 607 608 red: 609 call i8* @objc_retain(i8* %x) nounwind 610 br label %yellow 611 612 orange: 613 call i8* @objc_retain(i8* %x) nounwind 614 br label %yellow 615 616 yellow: 617 call void @use_pointer(i8* %x) 618 call void @use_pointer(i8* %x) 619 br i1 %b, label %green, label %blue 620 621 green: 622 call void @objc_release(i8* %x) nounwind 623 br label %purple 624 625 blue: 626 call void @objc_release(i8* %x) nounwind 627 br label %purple 628 629 purple: 630 call void @objc_release(i8* %x) nounwind 631 ret void 632 } 633 634 ; Delete no-ops. 635 636 ; CHECK: define void @test18( 637 ; CHECK-NOT: @objc_ 638 ; CHECK: } 639 define void @test18() { 640 call i8* @objc_retain(i8* null) 641 call void @objc_release(i8* null) 642 call i8* @objc_autorelease(i8* null) 643 ret void 644 } 645 646 ; Delete no-ops where undef can be assumed to be null. 647 648 ; CHECK: define void @test18b 649 ; CHECK-NOT: @objc_ 650 ; CHECK: } 651 define void @test18b() { 652 call i8* @objc_retain(i8* undef) 653 call void @objc_release(i8* undef) 654 call i8* @objc_autorelease(i8* undef) 655 ret void 656 } 657 658 ; Replace uses of arguments with uses of return values, to reduce 659 ; register pressure. 660 661 ; CHECK: define void @test19(i32* %y) { 662 ; CHECK: %z = bitcast i32* %y to i8* 663 ; CHECK: %0 = bitcast i32* %y to i8* 664 ; CHECK: %1 = tail call i8* @objc_retain(i8* %0) 665 ; CHECK: call void @use_pointer(i8* %z) 666 ; CHECK: call void @use_pointer(i8* %z) 667 ; CHECK: %2 = bitcast i32* %y to i8* 668 ; CHECK: call void @objc_release(i8* %2) 669 ; CHECK: ret void 670 ; CHECK: } 671 define void @test19(i32* %y) { 672 entry: 673 %x = bitcast i32* %y to i8* 674 %0 = call i8* @objc_retain(i8* %x) nounwind 675 %z = bitcast i32* %y to i8* 676 call void @use_pointer(i8* %z) 677 call void @use_pointer(i8* %z) 678 call void @objc_release(i8* %x) 679 ret void 680 } 681 682 ; Bitcast insertion 683 684 ; CHECK: define void @test20( 685 ; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) nounwind 686 ; CHECK-NEXT: invoke 687 define void @test20(double* %self) { 688 if.then12: 689 %tmp = bitcast double* %self to i8* 690 %tmp1 = call i8* @objc_retain(i8* %tmp) nounwind 691 invoke void @invokee() 692 to label %invoke.cont23 unwind label %lpad20 693 694 invoke.cont23: ; preds = %if.then12 695 invoke void @invokee() 696 to label %if.end unwind label %lpad20 697 698 lpad20: ; preds = %invoke.cont23, %if.then12 699 %tmp502 = phi double* [ undef, %invoke.cont23 ], [ %self, %if.then12 ] 700 unreachable 701 702 if.end: ; preds = %invoke.cont23 703 ret void 704 } 705 706 ; Delete a redundant retain,autorelease when forwaring a call result 707 ; directly to a return value. 708 709 ; CHECK: define i8* @test21( 710 ; CHECK: call i8* @returner() 711 ; CHECK-NEXT: ret i8* %call 712 define i8* @test21() { 713 entry: 714 %call = call i8* @returner() 715 %0 = call i8* @objc_retain(i8* %call) nounwind 716 %1 = call i8* @objc_autorelease(i8* %0) nounwind 717 ret i8* %1 718 } 719 720 ; Move an objc call up through a phi that has null operands. 721 722 ; CHECK: define void @test22( 723 ; CHECK: B: 724 ; CHECK: %1 = bitcast double* %p to i8* 725 ; CHECK: call void @objc_release(i8* %1) 726 ; CHECK: br label %C 727 ; CHECK: C: ; preds = %B, %A 728 ; CHECK-NOT: @objc_release 729 ; CHECK: } 730 define void @test22(double* %p, i1 %a) { 731 br i1 %a, label %A, label %B 732 A: 733 br label %C 734 B: 735 br label %C 736 C: 737 %h = phi double* [ null, %A ], [ %p, %B ] 738 %c = bitcast double* %h to i8* 739 call void @objc_release(i8* %c) 740 ret void 741 } 742 743 ; Optimize objc_retainBlock. 744 745 ; CHECK: define void @test23( 746 ; CHECK-NOT: @objc_ 747 ; CHECK: } 748 %block0 = type { i64, i64, i8*, i8* } 749 %block1 = type { i8**, i32, i32, i32 (%struct.__block_literal_1*)*, %block0* } 750 %struct.__block_descriptor = type { i64, i64 } 751 %struct.__block_literal_1 = type { i8**, i32, i32, i8**, %struct.__block_descriptor* } 752 @__block_holder_tmp_1 = external constant %block1 753 define void @test23() { 754 entry: 755 %0 = call i8* @objc_retainBlock(i8* bitcast (%block1* @__block_holder_tmp_1 to i8*)) nounwind 756 call void @bar(i32 ()* bitcast (%block1* @__block_holder_tmp_1 to i32 ()*)) 757 call void @bar(i32 ()* bitcast (%block1* @__block_holder_tmp_1 to i32 ()*)) 758 call void @objc_release(i8* bitcast (%block1* @__block_holder_tmp_1 to i8*)) nounwind 759 ret void 760 } 761 762 ; Don't optimize objc_retainBlock. 763 764 ; CHECK: define void @test23b 765 ; CHECK: @objc_retainBlock 766 ; CHECK: @objc_release 767 ; CHECK: } 768 define void @test23b(i8* %p) { 769 entry: 770 %0 = call i8* @objc_retainBlock(i8* %p) nounwind 771 call void @use_pointer(i8* %p) 772 call void @use_pointer(i8* %p) 773 call void @objc_release(i8* %p) nounwind 774 ret void 775 } 776 777 ; Any call can decrement a retain count. 778 779 ; CHECK: define void @test24( 780 ; CHECK: @objc_retain(i8* %a) 781 ; CHECK: @objc_release 782 ; CHECK: } 783 define void @test24(i8* %r, i8* %a) { 784 call i8* @objc_retain(i8* %a) 785 call void @use_pointer(i8* %r) 786 %q = load i8* %a 787 call void @objc_release(i8* %a) 788 ret void 789 } 790 791 ; Don't move a retain/release pair if the release can be moved 792 ; but the retain can't be moved to balance it. 793 794 ; CHECK: define void @test25( 795 ; CHECK: entry: 796 ; CHECK: call i8* @objc_retain(i8* %p) 797 ; CHECK: true: 798 ; CHECK: done: 799 ; CHECK: call void @objc_release(i8* %p) 800 ; CHECK: } 801 define void @test25(i8* %p, i1 %x) { 802 entry: 803 %f0 = call i8* @objc_retain(i8* %p) 804 call void @callee() 805 br i1 %x, label %true, label %done 806 807 true: 808 store i8 0, i8* %p 809 br label %done 810 811 done: 812 call void @objc_release(i8* %p) 813 ret void 814 } 815 816 ; Don't move a retain/release pair if the retain can be moved 817 ; but the release can't be moved to balance it. 818 819 ; CHECK: define void @test26( 820 ; CHECK: entry: 821 ; CHECK: call i8* @objc_retain(i8* %p) 822 ; CHECK: true: 823 ; CHECK: done: 824 ; CHECK: call void @objc_release(i8* %p) 825 ; CHECK: } 826 define void @test26(i8* %p, i1 %x) { 827 entry: 828 %f0 = call i8* @objc_retain(i8* %p) 829 br i1 %x, label %true, label %done 830 831 true: 832 call void @callee() 833 br label %done 834 835 done: 836 store i8 0, i8* %p 837 call void @objc_release(i8* %p) 838 ret void 839 } 840 841 ; Don't sink the retain,release into the loop. 842 843 ; CHECK: define void @test27( 844 ; CHECK: entry: 845 ; CHECK: call i8* @objc_retain(i8* %p) 846 ; CHECK: loop: 847 ; CHECK-NOT: @objc_ 848 ; CHECK: done: 849 ; CHECK: call void @objc_release 850 ; CHECK: } 851 define void @test27(i8* %p, i1 %x, i1 %y) { 852 entry: 853 %f0 = call i8* @objc_retain(i8* %p) 854 br i1 %x, label %loop, label %done 855 856 loop: 857 call void @callee() 858 store i8 0, i8* %p 859 br i1 %y, label %done, label %loop 860 861 done: 862 call void @objc_release(i8* %p) 863 ret void 864 } 865 866 ; Trivial code motion case: Triangle. 867 868 ; CHECK: define void @test28( 869 ; CHECK-NOT: @objc_ 870 ; CHECK: true: 871 ; CHECK: call i8* @objc_retain( 872 ; CHECK: call void @callee() 873 ; CHECK: store 874 ; CHECK: call void @objc_release 875 ; CHECK: done: 876 ; CHECK-NOT: @objc_ 877 ; CHECK: } 878 define void @test28(i8* %p, i1 %x) { 879 entry: 880 %f0 = call i8* @objc_retain(i8* %p) 881 br i1 %x, label %true, label %done 882 883 true: 884 call void @callee() 885 store i8 0, i8* %p 886 br label %done 887 888 done: 889 call void @objc_release(i8* %p), !clang.imprecise_release !0 890 ret void 891 } 892 893 ; Trivial code motion case: Triangle, but no metadata. Don't move past 894 ; unrelated memory references! 895 896 ; CHECK: define void @test28b 897 ; CHECK: call i8* @objc_retain( 898 ; CHECK: true: 899 ; CHECK-NOT: @objc_ 900 ; CHECK: call void @callee() 901 ; CHECK-NOT: @objc_ 902 ; CHECK: store 903 ; CHECK-NOT: @objc_ 904 ; CHECK: done: 905 ; CHECK: @objc_release 906 ; CHECK: } 907 define void @test28b(i8* %p, i1 %x, i8* noalias %t) { 908 entry: 909 %f0 = call i8* @objc_retain(i8* %p) 910 br i1 %x, label %true, label %done 911 912 true: 913 call void @callee() 914 store i8 0, i8* %p 915 br label %done 916 917 done: 918 store i8 0, i8* %t 919 call void @objc_release(i8* %p) 920 ret void 921 } 922 923 ; Trivial code motion case: Triangle, with metadata. Do move past 924 ; unrelated memory references! And preserve the metadata. 925 926 ; CHECK: define void @test28c 927 ; CHECK-NOT: @objc_ 928 ; CHECK: true: 929 ; CHECK: call i8* @objc_retain( 930 ; CHECK: call void @callee() 931 ; CHECK: store 932 ; CHECK: call void @objc_release(i8* %p) nounwind, !clang.imprecise_release 933 ; CHECK: done: 934 ; CHECK-NOT: @objc_ 935 ; CHECK: } 936 define void @test28c(i8* %p, i1 %x, i8* noalias %t) { 937 entry: 938 %f0 = call i8* @objc_retain(i8* %p) 939 br i1 %x, label %true, label %done 940 941 true: 942 call void @callee() 943 store i8 0, i8* %p 944 br label %done 945 946 done: 947 store i8 0, i8* %t 948 call void @objc_release(i8* %p), !clang.imprecise_release !0 949 ret void 950 } 951 952 ; Like test28. but with two releases. 953 954 ; CHECK: define void @test29( 955 ; CHECK-NOT: @objc_ 956 ; CHECK: true: 957 ; CHECK: call i8* @objc_retain( 958 ; CHECK: call void @callee() 959 ; CHECK: store 960 ; CHECK: call void @objc_release 961 ; CHECK-NOT: @objc_release 962 ; CHECK: done: 963 ; CHECK-NOT: @objc_ 964 ; CHECK: ohno: 965 ; CHECK-NOT: @objc_ 966 ; CHECK: } 967 define void @test29(i8* %p, i1 %x, i1 %y) { 968 entry: 969 %f0 = call i8* @objc_retain(i8* %p) 970 br i1 %x, label %true, label %done 971 972 true: 973 call void @callee() 974 store i8 0, i8* %p 975 br i1 %y, label %done, label %ohno 976 977 done: 978 call void @objc_release(i8* %p) 979 ret void 980 981 ohno: 982 call void @objc_release(i8* %p) 983 ret void 984 } 985 986 ; Basic case with the use and call in a diamond 987 ; with an extra release. 988 989 ; CHECK: define void @test30( 990 ; CHECK-NOT: @objc_ 991 ; CHECK: true: 992 ; CHECK: call i8* @objc_retain( 993 ; CHECK: call void @callee() 994 ; CHECK: store 995 ; CHECK: call void @objc_release 996 ; CHECK-NOT: @objc_release 997 ; CHECK: false: 998 ; CHECK-NOT: @objc_ 999 ; CHECK: done: 1000 ; CHECK-NOT: @objc_ 1001 ; CHECK: ohno: 1002 ; CHECK-NOT: @objc_ 1003 ; CHECK: } 1004 define void @test30(i8* %p, i1 %x, i1 %y, i1 %z) { 1005 entry: 1006 %f0 = call i8* @objc_retain(i8* %p) 1007 br i1 %x, label %true, label %false 1008 1009 true: 1010 call void @callee() 1011 store i8 0, i8* %p 1012 br i1 %y, label %done, label %ohno 1013 1014 false: 1015 br i1 %z, label %done, label %ohno 1016 1017 done: 1018 call void @objc_release(i8* %p) 1019 ret void 1020 1021 ohno: 1022 call void @objc_release(i8* %p) 1023 ret void 1024 } 1025 1026 ; Basic case with a mergeable release. 1027 1028 ; CHECK: define void @test31( 1029 ; CHECK: call i8* @objc_retain(i8* %p) 1030 ; CHECK: call void @callee() 1031 ; CHECK: store 1032 ; CHECK: call void @objc_release 1033 ; CHECK-NOT: @objc_release 1034 ; CHECK: true: 1035 ; CHECK-NOT: @objc_release 1036 ; CHECK: false: 1037 ; CHECK-NOT: @objc_release 1038 ; CHECK: ret void 1039 ; CHECK-NOT: @objc_release 1040 ; CHECK: } 1041 define void @test31(i8* %p, i1 %x) { 1042 entry: 1043 %f0 = call i8* @objc_retain(i8* %p) 1044 call void @callee() 1045 store i8 0, i8* %p 1046 br i1 %x, label %true, label %false 1047 true: 1048 call void @objc_release(i8* %p) 1049 ret void 1050 false: 1051 call void @objc_release(i8* %p) 1052 ret void 1053 } 1054 1055 ; Don't consider bitcasts or getelementptrs direct uses. 1056 1057 ; CHECK: define void @test32( 1058 ; CHECK-NOT: @objc_ 1059 ; CHECK: true: 1060 ; CHECK: call i8* @objc_retain( 1061 ; CHECK: call void @callee() 1062 ; CHECK: store 1063 ; CHECK: call void @objc_release 1064 ; CHECK: done: 1065 ; CHECK-NOT: @objc_ 1066 ; CHECK: } 1067 define void @test32(i8* %p, i1 %x) { 1068 entry: 1069 %f0 = call i8* @objc_retain(i8* %p) 1070 br i1 %x, label %true, label %done 1071 1072 true: 1073 call void @callee() 1074 store i8 0, i8* %p 1075 br label %done 1076 1077 done: 1078 %g = bitcast i8* %p to i8* 1079 %h = getelementptr i8* %g, i64 0 1080 call void @objc_release(i8* %g) 1081 ret void 1082 } 1083 1084 ; Do consider icmps to be direct uses. 1085 1086 ; CHECK: define void @test33( 1087 ; CHECK-NOT: @objc_ 1088 ; CHECK: true: 1089 ; CHECK: call i8* @objc_retain( 1090 ; CHECK: call void @callee() 1091 ; CHECK: icmp 1092 ; CHECK: call void @objc_release 1093 ; CHECK: done: 1094 ; CHECK-NOT: @objc_ 1095 ; CHECK: } 1096 define void @test33(i8* %p, i1 %x, i8* %y) { 1097 entry: 1098 %f0 = call i8* @objc_retain(i8* %p) 1099 br i1 %x, label %true, label %done 1100 1101 true: 1102 call void @callee() 1103 %v = icmp eq i8* %p, %y 1104 br label %done 1105 1106 done: 1107 %g = bitcast i8* %p to i8* 1108 %h = getelementptr i8* %g, i64 0 1109 call void @objc_release(i8* %g) 1110 ret void 1111 } 1112 1113 ; Delete retain,release if there's just a possible dec. 1114 1115 ; CHECK: define void @test34( 1116 ; CHECK-NOT: @objc_ 1117 ; CHECK: } 1118 define void @test34(i8* %p, i1 %x, i8* %y) { 1119 entry: 1120 %f0 = call i8* @objc_retain(i8* %p) 1121 br i1 %x, label %true, label %done 1122 1123 true: 1124 call void @callee() 1125 br label %done 1126 1127 done: 1128 %g = bitcast i8* %p to i8* 1129 %h = getelementptr i8* %g, i64 0 1130 call void @objc_release(i8* %g) 1131 ret void 1132 } 1133 1134 ; Delete retain,release if there's just a use. 1135 1136 ; CHECK: define void @test35( 1137 ; CHECK-NOT: @objc_ 1138 ; CHECK: } 1139 define void @test35(i8* %p, i1 %x, i8* %y) { 1140 entry: 1141 %f0 = call i8* @objc_retain(i8* %p) 1142 br i1 %x, label %true, label %done 1143 1144 true: 1145 %v = icmp eq i8* %p, %y 1146 br label %done 1147 1148 done: 1149 %g = bitcast i8* %p to i8* 1150 %h = getelementptr i8* %g, i64 0 1151 call void @objc_release(i8* %g) 1152 ret void 1153 } 1154 1155 ; Delete a retain,release if there's no actual use. 1156 1157 ; CHECK: define void @test36( 1158 ; CHECK-NOT: @objc_ 1159 ; CHECK: call void @callee() 1160 ; CHECK-NOT: @objc_ 1161 ; CHECK: call void @callee() 1162 ; CHECK-NOT: @objc_ 1163 ; CHECK: } 1164 define void @test36(i8* %p) { 1165 entry: 1166 call i8* @objc_retain(i8* %p) 1167 call void @callee() 1168 call void @callee() 1169 call void @objc_release(i8* %p) 1170 ret void 1171 } 1172 1173 ; Like test36, but with metadata. 1174 1175 ; CHECK: define void @test37( 1176 ; CHECK-NOT: @objc_ 1177 ; CHECK: } 1178 define void @test37(i8* %p) { 1179 entry: 1180 call i8* @objc_retain(i8* %p) 1181 call void @callee() 1182 call void @callee() 1183 call void @objc_release(i8* %p), !clang.imprecise_release !0 1184 ret void 1185 } 1186 1187 ; Be aggressive about analyzing phis to eliminate possible uses. 1188 1189 ; CHECK: define void @test38( 1190 ; CHECK-NOT: @objc_ 1191 ; CHECK: } 1192 define void @test38(i8* %p, i1 %u, i1 %m, i8* %z, i8* %y, i8* %x, i8* %w) { 1193 entry: 1194 call i8* @objc_retain(i8* %p) 1195 br i1 %u, label %true, label %false 1196 true: 1197 br i1 %m, label %a, label %b 1198 false: 1199 br i1 %m, label %c, label %d 1200 a: 1201 br label %e 1202 b: 1203 br label %e 1204 c: 1205 br label %f 1206 d: 1207 br label %f 1208 e: 1209 %j = phi i8* [ %z, %a ], [ %y, %b ] 1210 br label %g 1211 f: 1212 %k = phi i8* [ %w, %c ], [ %x, %d ] 1213 br label %g 1214 g: 1215 %h = phi i8* [ %j, %e ], [ %k, %f ] 1216 call void @use_pointer(i8* %h) 1217 call void @objc_release(i8* %p), !clang.imprecise_release !0 1218 ret void 1219 } 1220 1221 ; Delete retain,release pairs around loops. 1222 1223 ; CHECK: define void @test39( 1224 ; CHECK_NOT: @objc_ 1225 ; CHECK: } 1226 define void @test39(i8* %p) { 1227 entry: 1228 %0 = call i8* @objc_retain(i8* %p) 1229 br label %loop 1230 1231 loop: ; preds = %loop, %entry 1232 br i1 undef, label %loop, label %exit 1233 1234 exit: ; preds = %loop 1235 call void @objc_release(i8* %0), !clang.imprecise_release !0 1236 ret void 1237 } 1238 1239 ; Delete retain,release pairs around loops containing uses. 1240 1241 ; CHECK: define void @test39b( 1242 ; CHECK_NOT: @objc_ 1243 ; CHECK: } 1244 define void @test39b(i8* %p) { 1245 entry: 1246 %0 = call i8* @objc_retain(i8* %p) 1247 br label %loop 1248 1249 loop: ; preds = %loop, %entry 1250 store i8 0, i8* %0 1251 br i1 undef, label %loop, label %exit 1252 1253 exit: ; preds = %loop 1254 call void @objc_release(i8* %0), !clang.imprecise_release !0 1255 ret void 1256 } 1257 1258 ; Delete retain,release pairs around loops containing potential decrements. 1259 1260 ; CHECK: define void @test39c( 1261 ; CHECK_NOT: @objc_ 1262 ; CHECK: } 1263 define void @test39c(i8* %p) { 1264 entry: 1265 %0 = call i8* @objc_retain(i8* %p) 1266 br label %loop 1267 1268 loop: ; preds = %loop, %entry 1269 call void @use_pointer(i8* %0) 1270 br i1 undef, label %loop, label %exit 1271 1272 exit: ; preds = %loop 1273 call void @objc_release(i8* %0), !clang.imprecise_release !0 1274 ret void 1275 } 1276 1277 ; Delete retain,release pairs around loops even if 1278 ; the successors are in a different order. 1279 1280 ; CHECK: define void @test40( 1281 ; CHECK_NOT: @objc_ 1282 ; CHECK: } 1283 define void @test40(i8* %p) { 1284 entry: 1285 %0 = call i8* @objc_retain(i8* %p) 1286 br label %loop 1287 1288 loop: ; preds = %loop, %entry 1289 call void @use_pointer(i8* %0) 1290 br i1 undef, label %exit, label %loop 1291 1292 exit: ; preds = %loop 1293 call void @objc_release(i8* %0), !clang.imprecise_release !0 1294 ret void 1295 } 1296 1297 ; Do the known-incremented retain+release elimination even if the pointer 1298 ; is also autoreleased. 1299 1300 ; CHECK: define void @test42( 1301 ; CHECK-NEXT: entry: 1302 ; CHECK-NEXT: call i8* @objc_retain(i8* %p) 1303 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p) 1304 ; CHECK-NEXT: call void @use_pointer(i8* %p) 1305 ; CHECK-NEXT: call void @use_pointer(i8* %p) 1306 ; CHECK-NEXT: ret void 1307 ; CHECK-NEXT: } 1308 define void @test42(i8* %p) { 1309 entry: 1310 call i8* @objc_retain(i8* %p) 1311 call i8* @objc_autorelease(i8* %p) 1312 call i8* @objc_retain(i8* %p) 1313 call void @use_pointer(i8* %p) 1314 call void @use_pointer(i8* %p) 1315 call void @objc_release(i8* %p) 1316 ret void 1317 } 1318 1319 ; Don't the known-incremented retain+release elimination if the pointer is 1320 ; autoreleased and there's an autoreleasePoolPop. 1321 1322 ; CHECK: define void @test43( 1323 ; CHECK-NEXT: entry: 1324 ; CHECK-NEXT: call i8* @objc_retain(i8* %p) 1325 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p) 1326 ; CHECK-NEXT: call i8* @objc_retain 1327 ; CHECK-NEXT: call void @use_pointer(i8* %p) 1328 ; CHECK-NEXT: call void @use_pointer(i8* %p) 1329 ; CHECK-NEXT: call void @objc_autoreleasePoolPop(i8* undef) 1330 ; CHECK-NEXT: call void @objc_release 1331 ; CHECK-NEXT: ret void 1332 ; CHECK-NEXT: } 1333 define void @test43(i8* %p) { 1334 entry: 1335 call i8* @objc_retain(i8* %p) 1336 call i8* @objc_autorelease(i8* %p) 1337 call i8* @objc_retain(i8* %p) 1338 call void @use_pointer(i8* %p) 1339 call void @use_pointer(i8* %p) 1340 call void @objc_autoreleasePoolPop(i8* undef) 1341 call void @objc_release(i8* %p) 1342 ret void 1343 } 1344 1345 ; Do the known-incremented retain+release elimination if the pointer is 1346 ; autoreleased and there's an autoreleasePoolPush. 1347 1348 ; CHECK: define void @test43b 1349 ; CHECK-NEXT: entry: 1350 ; CHECK-NEXT: call i8* @objc_retain(i8* %p) 1351 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p) 1352 ; CHECK-NEXT: call void @use_pointer(i8* %p) 1353 ; CHECK-NEXT: call void @use_pointer(i8* %p) 1354 ; CHECK-NEXT: call void @objc_autoreleasePoolPush() 1355 ; CHECK-NEXT: ret void 1356 ; CHECK-NEXT: } 1357 define void @test43b(i8* %p) { 1358 entry: 1359 call i8* @objc_retain(i8* %p) 1360 call i8* @objc_autorelease(i8* %p) 1361 call i8* @objc_retain(i8* %p) 1362 call void @use_pointer(i8* %p) 1363 call void @use_pointer(i8* %p) 1364 call void @objc_autoreleasePoolPush() 1365 call void @objc_release(i8* %p) 1366 ret void 1367 } 1368 1369 ; Do retain+release elimination for non-provenance pointers. 1370 1371 ; CHECK: define void @test44( 1372 ; CHECK-NOT: objc_ 1373 ; CHECK: } 1374 define void @test44(i8** %pp) { 1375 %p = load i8** %pp 1376 %q = call i8* @objc_retain(i8* %p) 1377 call void @objc_release(i8* %q) 1378 ret void 1379 } 1380 1381 ; Don't delete retain+release with an unknown-provenance 1382 ; may-alias objc_release between them. 1383 1384 ; CHECK: define void @test45( 1385 ; CHECK: call i8* @objc_retain(i8* %p) 1386 ; CHECK: call void @objc_release(i8* %q) 1387 ; CHECK: call void @use_pointer(i8* %p) 1388 ; CHECK: call void @objc_release(i8* %p) 1389 define void @test45(i8** %pp, i8** %qq) { 1390 %p = load i8** %pp 1391 %q = load i8** %qq 1392 call i8* @objc_retain(i8* %p) 1393 call void @objc_release(i8* %q) 1394 call void @use_pointer(i8* %p) 1395 call void @objc_release(i8* %p) 1396 ret void 1397 } 1398 1399 ; Don't delete retain and autorelease here. 1400 1401 ; CHECK: define void @test46( 1402 ; CHECK: tail call i8* @objc_retain(i8* %p) nounwind 1403 ; CHECK: true: 1404 ; CHECK: tail call i8* @objc_autorelease(i8* %p) nounwind 1405 define void @test46(i8* %p, i1 %a) { 1406 entry: 1407 call i8* @objc_retain(i8* %p) 1408 br i1 %a, label %true, label %false 1409 1410 true: 1411 call i8* @objc_autorelease(i8* %p) 1412 call void @use_pointer(i8* %p) 1413 ret void 1414 1415 false: 1416 ret void 1417 } 1418 1419 ; Delete no-op cast calls. 1420 1421 ; CHECK: define i8* @test47( 1422 ; CHECK-NOT: call 1423 ; CHECK: ret i8* %p 1424 define i8* @test47(i8* %p) nounwind { 1425 %x = call i8* @objc_retainedObject(i8* %p) 1426 ret i8* %x 1427 } 1428 1429 ; Delete no-op cast calls. 1430 1431 ; CHECK: define i8* @test48( 1432 ; CHECK-NOT: call 1433 ; CHECK: ret i8* %p 1434 define i8* @test48(i8* %p) nounwind { 1435 %x = call i8* @objc_unretainedObject(i8* %p) 1436 ret i8* %x 1437 } 1438 1439 ; Delete no-op cast calls. 1440 1441 ; CHECK: define i8* @test49( 1442 ; CHECK-NOT: call 1443 ; CHECK: ret i8* %p 1444 define i8* @test49(i8* %p) nounwind { 1445 %x = call i8* @objc_unretainedPointer(i8* %p) 1446 ret i8* %x 1447 } 1448 1449 ; Do delete retain+release with intervening stores of the 1450 ; address value; 1451 1452 ; CHECK: define void @test50( 1453 ; CHECK-NOT: @objc_ 1454 ; CHECK: } 1455 define void @test50(i8* %p, i8** %pp) { 1456 call i8* @objc_retain(i8* %p) 1457 call void @callee() 1458 store i8* %p, i8** %pp 1459 call void @objc_release(i8* %p) 1460 ret void 1461 } 1462 1463 ; Don't delete retain+release with intervening stores through the 1464 ; address value. 1465 1466 ; CHECK: define void @test51( 1467 ; CHECK: call i8* @objc_retain(i8* %p) 1468 ; CHECK: call void @objc_release(i8* %p) 1469 define void @test51(i8* %p) { 1470 call i8* @objc_retain(i8* %p) 1471 call void @callee() 1472 store i8 0, i8* %p 1473 call void @objc_release(i8* %p) 1474 ret void 1475 } 1476 1477 ; Don't delete retain+release with intervening use of a pointer of 1478 ; unknown provenance. 1479 1480 ; CHECK: define void @test52( 1481 ; CHECK: call i8* @objc_retain 1482 ; CHECK: call void @callee() 1483 ; CHECK: call void @use_pointer(i8* %z) 1484 ; CHECK: call void @objc_release 1485 define void @test52(i8** %zz, i8** %pp) { 1486 %p = load i8** %pp 1487 %1 = call i8* @objc_retain(i8* %p) 1488 call void @callee() 1489 %z = load i8** %zz 1490 call void @use_pointer(i8* %z) 1491 call void @objc_release(i8* %p) 1492 ret void 1493 } 1494 1495 ; Like test52, but the pointer has function type, so it's assumed to 1496 ; be not reference counted. 1497 1498 ; CHECK: define void @test53( 1499 ; CHECK-NOT: @objc_ 1500 ; CHECK: } 1501 define void @test53(void ()** %zz, i8** %pp) { 1502 %p = load i8** %pp 1503 %1 = call i8* @objc_retain(i8* %p) 1504 call void @callee() 1505 %z = load void ()** %zz 1506 call void @callee_fnptr(void ()* %z) 1507 call void @objc_release(i8* %p) 1508 ret void 1509 } 1510 1511 ; Convert autorelease to release if the value is unused. 1512 1513 ; CHECK: define void @test54( 1514 ; CHECK: call i8* @returner() 1515 ; CHECK-NEXT: call void @objc_release(i8* %t) nounwind, !clang.imprecise_release !0 1516 ; CHECK-NEXT: ret void 1517 define void @test54() { 1518 %t = call i8* @returner() 1519 call i8* @objc_autorelease(i8* %t) 1520 ret void 1521 } 1522 1523 ; Nested retain+release pairs. Delete them both. 1524 1525 ; CHECK: define void @test55( 1526 ; CHECK-NOT: @objc 1527 ; CHECK: } 1528 define void @test55(i8* %x) { 1529 entry: 1530 %0 = call i8* @objc_retain(i8* %x) nounwind 1531 %1 = call i8* @objc_retain(i8* %x) nounwind 1532 call void @objc_release(i8* %x) nounwind 1533 call void @objc_release(i8* %x) nounwind 1534 ret void 1535 } 1536 1537 ; Nested retain+release pairs where the inner pair depends 1538 ; on the outer pair to be removed, and then the outer pair 1539 ; can be partially eliminated. Plus an extra outer pair to 1540 ; eliminate, for fun. 1541 1542 ; CHECK: define void @test56( 1543 ; CHECK-NOT: @objc 1544 ; CHECK: if.then: 1545 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) nounwind 1546 ; CHECK-NEXT: tail call void @use_pointer(i8* %x) 1547 ; CHECK-NEXT: tail call void @use_pointer(i8* %x) 1548 ; CHECK-NEXT: tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0 1549 ; CHECK-NEXT: br label %if.end 1550 ; CHECK-NOT: @objc 1551 ; CHECK: } 1552 define void @test56(i8* %x, i32 %n) { 1553 entry: 1554 %0 = tail call i8* @objc_retain(i8* %x) nounwind 1555 %1 = tail call i8* @objc_retain(i8* %0) nounwind 1556 %tobool = icmp eq i32 %n, 0 1557 br i1 %tobool, label %if.end, label %if.then 1558 1559 if.then: ; preds = %entry 1560 %2 = tail call i8* @objc_retain(i8* %1) nounwind 1561 tail call void @use_pointer(i8* %2) 1562 tail call void @use_pointer(i8* %2) 1563 tail call void @objc_release(i8* %2) nounwind, !clang.imprecise_release !0 1564 br label %if.end 1565 1566 if.end: ; preds = %entry, %if.then 1567 tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0 1568 tail call void @objc_release(i8* %0) nounwind, !clang.imprecise_release !0 1569 ret void 1570 } 1571 1572 declare void @bar(i32 ()*) 1573 1574 ; A few real-world testcases. 1575 1576 @.str4 = private unnamed_addr constant [33 x i8] c"-[A z] = { %f, %f, { %f, %f } }\0A\00" 1577 @"OBJC_IVAR_$_A.myZ" = global i64 20, section "__DATA, __objc_const", align 8 1578 declare i32 @printf(i8* nocapture, ...) nounwind 1579 declare i32 @puts(i8* nocapture) nounwind 1580 @str = internal constant [16 x i8] c"-[ Top0 _getX ]\00" 1581 1582 ; CHECK: @"\01-[A z]" 1583 ; CHECK-NOT: @objc_ 1584 ; CHECK: } 1585 1586 define {<2 x float>, <2 x float>} @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind { 1587 invoke.cont: 1588 %0 = bitcast {}* %self to i8* 1589 %1 = tail call i8* @objc_retain(i8* %0) nounwind 1590 tail call void @llvm.dbg.value(metadata !{{}* %self}, i64 0, metadata !0) 1591 tail call void @llvm.dbg.value(metadata !{{}* %self}, i64 0, metadata !0) 1592 %ivar = load i64* @"OBJC_IVAR_$_A.myZ", align 8 1593 %add.ptr = getelementptr i8* %0, i64 %ivar 1594 %tmp1 = bitcast i8* %add.ptr to float* 1595 %tmp2 = load float* %tmp1, align 4 1596 %conv = fpext float %tmp2 to double 1597 %add.ptr.sum = add i64 %ivar, 4 1598 %tmp6 = getelementptr inbounds i8* %0, i64 %add.ptr.sum 1599 %2 = bitcast i8* %tmp6 to float* 1600 %tmp7 = load float* %2, align 4 1601 %conv8 = fpext float %tmp7 to double 1602 %add.ptr.sum36 = add i64 %ivar, 8 1603 %tmp12 = getelementptr inbounds i8* %0, i64 %add.ptr.sum36 1604 %arrayidx = bitcast i8* %tmp12 to float* 1605 %tmp13 = load float* %arrayidx, align 4 1606 %conv14 = fpext float %tmp13 to double 1607 %tmp12.sum = add i64 %ivar, 12 1608 %arrayidx19 = getelementptr inbounds i8* %0, i64 %tmp12.sum 1609 %3 = bitcast i8* %arrayidx19 to float* 1610 %tmp20 = load float* %3, align 4 1611 %conv21 = fpext float %tmp20 to double 1612 %call = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @.str4, i64 0, i64 0), double %conv, double %conv8, double %conv14, double %conv21) 1613 %ivar23 = load i64* @"OBJC_IVAR_$_A.myZ", align 8 1614 %add.ptr24 = getelementptr i8* %0, i64 %ivar23 1615 %4 = bitcast i8* %add.ptr24 to i128* 1616 %srcval = load i128* %4, align 4 1617 tail call void @objc_release(i8* %0) nounwind 1618 %tmp29 = trunc i128 %srcval to i64 1619 %tmp30 = bitcast i64 %tmp29 to <2 x float> 1620 %tmp31 = insertvalue {<2 x float>, <2 x float>} undef, <2 x float> %tmp30, 0 1621 %tmp32 = lshr i128 %srcval, 64 1622 %tmp33 = trunc i128 %tmp32 to i64 1623 %tmp34 = bitcast i64 %tmp33 to <2 x float> 1624 %tmp35 = insertvalue {<2 x float>, <2 x float>} %tmp31, <2 x float> %tmp34, 1 1625 ret {<2 x float>, <2 x float>} %tmp35 1626 } 1627 1628 ; CHECK: @"\01-[Top0 _getX]" 1629 ; CHECK-NOT: @objc_ 1630 ; CHECK: } 1631 1632 define i32 @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) nounwind { 1633 invoke.cont: 1634 %0 = bitcast {}* %self to i8* 1635 %1 = tail call i8* @objc_retain(i8* %0) nounwind 1636 %puts = tail call i32 @puts(i8* getelementptr inbounds ([16 x i8]* @str, i64 0, i64 0)) 1637 tail call void @objc_release(i8* %0) nounwind 1638 ret i32 0 1639 } 1640 1641 @"\01L_OBJC_METH_VAR_NAME_" = internal global [5 x i8] c"frob\00", section "__TEXT,__cstring,cstring_literals", align 1@"\01L_OBJC_SELECTOR_REFERENCES_" = internal global i8* getelementptr inbounds ([5 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1642 @"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip" 1643 @llvm.used = appending global [3 x i8*] [i8* getelementptr inbounds ([5 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i32 0, i32 0), i8* bitcast (i8** @"\01L_OBJC_SELECTOR_REFERENCES_" to i8*), i8* bitcast ([2 x i32]* @"\01L_OBJC_IMAGE_INFO" to i8*)], section "llvm.metadata" 1644 1645 ; A simple loop. Eliminate the retain and release inside of it! 1646 1647 ; CHECK: define void @loop 1648 ; CHECK: for.body: 1649 ; CHECK-NOT: @objc_ 1650 ; CHECK: @objc_msgSend 1651 ; CHECK-NOT: @objc_ 1652 ; CHECK: for.end: 1653 define void @loop(i8* %x, i64 %n) { 1654 entry: 1655 %0 = tail call i8* @objc_retain(i8* %x) nounwind 1656 %cmp9 = icmp sgt i64 %n, 0 1657 br i1 %cmp9, label %for.body, label %for.end 1658 1659 for.body: ; preds = %entry, %for.body 1660 %i.010 = phi i64 [ %inc, %for.body ], [ 0, %entry ] 1661 %1 = tail call i8* @objc_retain(i8* %x) nounwind 1662 %tmp5 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8 1663 %call = tail call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %1, i8* %tmp5) 1664 tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0 1665 %inc = add nsw i64 %i.010, 1 1666 %exitcond = icmp eq i64 %inc, %n 1667 br i1 %exitcond, label %for.end, label %for.body 1668 1669 for.end: ; preds = %for.body, %entry 1670 tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0 1671 ret void 1672 } 1673 1674 ; ObjCARCOpt can delete the retain,release on self. 1675 1676 ; CHECK: define void @TextEditTest 1677 ; CHECK-NOT: call i8* @objc_retain(i8* %tmp7) 1678 ; CHECK: } 1679 1680 %0 = type { i8* (i8*, %struct._message_ref_t*, ...)*, i8* } 1681 %1 = type opaque 1682 %2 = type opaque 1683 %3 = type opaque 1684 %4 = type opaque 1685 %5 = type opaque 1686 %struct.NSConstantString = type { i32*, i32, i8*, i64 } 1687 %struct._NSRange = type { i64, i64 } 1688 %struct.__CFString = type opaque 1689 %struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] } 1690 %struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* } 1691 %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* } 1692 %struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] } 1693 %struct._ivar_t = type { i64*, i8*, i8*, i32, i32 } 1694 %struct._message_ref_t = type { i8*, i8* } 1695 %struct._objc_cache = type opaque 1696 %struct._objc_method = type { i8*, i8*, i8* } 1697 %struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] } 1698 %struct._prop_list_t = type { i32, i32, [0 x %struct._message_ref_t] } 1699 %struct._protocol_t = type { i8*, i8*, %struct._objc_protocol_list*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._prop_list_t*, i32, i32 } 1700 1701 @"\01L_OBJC_CLASSLIST_REFERENCES_$_17" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 1702 @kUTTypePlainText = external constant %struct.__CFString* 1703 @"\01L_OBJC_SELECTOR_REFERENCES_19" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1704 @"\01L_OBJC_SELECTOR_REFERENCES_21" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1705 @"\01L_OBJC_SELECTOR_REFERENCES_23" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1706 @"\01L_OBJC_SELECTOR_REFERENCES_25" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1707 @"\01L_OBJC_CLASSLIST_REFERENCES_$_26" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 1708 @"\01L_OBJC_SELECTOR_REFERENCES_28" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1709 @"\01L_OBJC_CLASSLIST_REFERENCES_$_29" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 1710 @"\01L_OBJC_SELECTOR_REFERENCES_31" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1711 @"\01L_OBJC_SELECTOR_REFERENCES_33" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1712 @"\01L_OBJC_SELECTOR_REFERENCES_35" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1713 @"\01L_OBJC_SELECTOR_REFERENCES_37" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1714 @"\01L_OBJC_CLASSLIST_REFERENCES_$_38" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 1715 @"\01L_OBJC_SELECTOR_REFERENCES_40" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1716 @"\01L_OBJC_SELECTOR_REFERENCES_42" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1717 @_unnamed_cfstring_44 = external hidden constant %struct.NSConstantString, section "__DATA,__cfstring" 1718 @"\01L_OBJC_SELECTOR_REFERENCES_46" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1719 @"\01L_OBJC_SELECTOR_REFERENCES_48" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1720 @"\01l_objc_msgSend_fixup_isEqual_" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16 1721 @"\01L_OBJC_CLASSLIST_REFERENCES_$_50" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 1722 @NSCocoaErrorDomain = external constant %1* 1723 @"\01L_OBJC_CLASSLIST_REFERENCES_$_51" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 1724 @NSFilePathErrorKey = external constant %1* 1725 @"\01L_OBJC_SELECTOR_REFERENCES_53" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1726 @"\01L_OBJC_SELECTOR_REFERENCES_55" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1727 @"\01L_OBJC_CLASSLIST_REFERENCES_$_56" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 1728 @"\01L_OBJC_SELECTOR_REFERENCES_58" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1729 @"\01L_OBJC_SELECTOR_REFERENCES_60" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" 1730 1731 declare %1* @truncatedString(%1*, i64) 1732 define void @TextEditTest(%2* %self, %3* %pboard) { 1733 entry: 1734 %err = alloca %4*, align 8 1735 %tmp7 = bitcast %2* %self to i8* 1736 %tmp8 = call i8* @objc_retain(i8* %tmp7) nounwind 1737 store %4* null, %4** %err, align 8 1738 %tmp1 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_17", align 8 1739 %tmp2 = load %struct.__CFString** @kUTTypePlainText, align 8 1740 %tmp3 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_19", align 8 1741 %tmp4 = bitcast %struct._class_t* %tmp1 to i8* 1742 %call5 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp4, i8* %tmp3, %struct.__CFString* %tmp2) 1743 %tmp5 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_21", align 8 1744 %tmp6 = bitcast %3* %pboard to i8* 1745 %call76 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp5, i8* %call5) 1746 %tmp9 = call i8* @objc_retain(i8* %call76) nounwind 1747 %tobool = icmp eq i8* %tmp9, null 1748 br i1 %tobool, label %end, label %land.lhs.true 1749 1750 land.lhs.true: ; preds = %entry 1751 %tmp11 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_23", align 8 1752 %call137 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp11, i8* %tmp9) 1753 %tmp = bitcast i8* %call137 to %1* 1754 %tmp10 = call i8* @objc_retain(i8* %call137) nounwind 1755 call void @objc_release(i8* null) nounwind 1756 %tmp12 = call i8* @objc_retain(i8* %call137) nounwind 1757 call void @objc_release(i8* null) nounwind 1758 %tobool16 = icmp eq i8* %call137, null 1759 br i1 %tobool16, label %end, label %if.then 1760 1761 if.then: ; preds = %land.lhs.true 1762 %tmp19 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8 1763 %call21 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %call137, i8* %tmp19) 1764 %tobool22 = icmp eq i8 %call21, 0 1765 br i1 %tobool22, label %if.then44, label %land.lhs.true23 1766 1767 land.lhs.true23: ; preds = %if.then 1768 %tmp24 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8 1769 %tmp26 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8 1770 %tmp27 = bitcast %struct._class_t* %tmp24 to i8* 1771 %call2822 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp27, i8* %tmp26, i8* %call137) 1772 %tmp13 = bitcast i8* %call2822 to %5* 1773 %tmp14 = call i8* @objc_retain(i8* %call2822) nounwind 1774 call void @objc_release(i8* null) nounwind 1775 %tobool30 = icmp eq i8* %call2822, null 1776 br i1 %tobool30, label %if.then44, label %if.end 1777 1778 if.end: ; preds = %land.lhs.true23 1779 %tmp32 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8 1780 %tmp33 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8 1781 %tmp34 = bitcast %struct._class_t* %tmp32 to i8* 1782 %call35 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp34, i8* %tmp33) 1783 %tmp37 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8 1784 %call3923 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call35, i8* %tmp37, i8* %call2822, i32 signext 1, %4** %err) 1785 %cmp = icmp eq i8* %call3923, null 1786 br i1 %cmp, label %if.then44, label %end 1787 1788 if.then44: ; preds = %if.end, %land.lhs.true23, %if.then 1789 %url.025 = phi %5* [ %tmp13, %if.end ], [ %tmp13, %land.lhs.true23 ], [ null, %if.then ] 1790 %tmp49 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_35", align 8 1791 %call51 = call %struct._NSRange bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %struct._NSRange (i8*, i8*, i64, i64)*)(i8* %call137, i8* %tmp49, i64 0, i64 0) 1792 %call513 = extractvalue %struct._NSRange %call51, 0 1793 %call514 = extractvalue %struct._NSRange %call51, 1 1794 %tmp52 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_37", align 8 1795 %call548 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call137, i8* %tmp52, i64 %call513, i64 %call514) 1796 %tmp55 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_38", align 8 1797 %tmp56 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_40", align 8 1798 %tmp57 = bitcast %struct._class_t* %tmp55 to i8* 1799 %call58 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp57, i8* %tmp56) 1800 %tmp59 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_42", align 8 1801 %call6110 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call548, i8* %tmp59, i8* %call58) 1802 %tmp15 = call i8* @objc_retain(i8* %call6110) nounwind 1803 call void @objc_release(i8* %call137) nounwind 1804 %tmp64 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_46", align 8 1805 %call66 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*, %1*)*)(i8* %call6110, i8* %tmp64, %1* bitcast (%struct.NSConstantString* @_unnamed_cfstring_44 to %1*)) 1806 %tobool67 = icmp eq i8 %call66, 0 1807 br i1 %tobool67, label %if.end74, label %if.then68 1808 1809 if.then68: ; preds = %if.then44 1810 %tmp70 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_48", align 8 1811 %call7220 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call6110, i8* %tmp70) 1812 %tmp16 = call i8* @objc_retain(i8* %call7220) nounwind 1813 call void @objc_release(i8* %call6110) nounwind 1814 br label %if.end74 1815 1816 if.end74: ; preds = %if.then68, %if.then44 1817 %filename.0.in = phi i8* [ %call7220, %if.then68 ], [ %call6110, %if.then44 ] 1818 %filename.0 = bitcast i8* %filename.0.in to %1* 1819 %tmp17 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to i8**), align 16 1820 %tmp18 = bitcast i8* %tmp17 to i8 (i8*, %struct._message_ref_t*, i8*, ...)* 1821 %call78 = call signext i8 (i8*, %struct._message_ref_t*, i8*, ...)* %tmp18(i8* %call137, %struct._message_ref_t* bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to %struct._message_ref_t*), i8* %filename.0.in) 1822 %tobool79 = icmp eq i8 %call78, 0 1823 br i1 %tobool79, label %land.lhs.true80, label %if.then109 1824 1825 land.lhs.true80: ; preds = %if.end74 1826 %tmp82 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8 1827 %call84 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %filename.0.in, i8* %tmp82) 1828 %tobool86 = icmp eq i8 %call84, 0 1829 br i1 %tobool86, label %if.then109, label %if.end106 1830 1831 if.end106: ; preds = %land.lhs.true80 1832 %tmp88 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8 1833 %tmp90 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8 1834 %tmp91 = bitcast %struct._class_t* %tmp88 to i8* 1835 %call9218 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp91, i8* %tmp90, i8* %filename.0.in) 1836 %tmp20 = bitcast i8* %call9218 to %5* 1837 %tmp21 = call i8* @objc_retain(i8* %call9218) nounwind 1838 %tmp22 = bitcast %5* %url.025 to i8* 1839 call void @objc_release(i8* %tmp22) nounwind 1840 %tmp94 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8 1841 %tmp95 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8 1842 %tmp96 = bitcast %struct._class_t* %tmp94 to i8* 1843 %call97 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp96, i8* %tmp95) 1844 %tmp99 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8 1845 %call10119 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call97, i8* %tmp99, i8* %call9218, i32 signext 1, %4** %err) 1846 %phitmp = icmp eq i8* %call10119, null 1847 br i1 %phitmp, label %if.then109, label %end 1848 1849 if.then109: ; preds = %if.end106, %land.lhs.true80, %if.end74 1850 %url.129 = phi %5* [ %tmp20, %if.end106 ], [ %url.025, %if.end74 ], [ %url.025, %land.lhs.true80 ] 1851 %tmp110 = load %4** %err, align 8 1852 %tobool111 = icmp eq %4* %tmp110, null 1853 br i1 %tobool111, label %if.then112, label %if.end125 1854 1855 if.then112: ; preds = %if.then109 1856 %tmp113 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_50", align 8 1857 %tmp114 = load %1** @NSCocoaErrorDomain, align 8 1858 %tmp115 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_51", align 8 1859 %call117 = call %1* @truncatedString(%1* %filename.0, i64 1034) 1860 %tmp118 = load %1** @NSFilePathErrorKey, align 8 1861 %tmp119 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_53", align 8 1862 %tmp120 = bitcast %struct._class_t* %tmp115 to i8* 1863 %call12113 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp120, i8* %tmp119, %1* %call117, %1* %tmp118, i8* null) 1864 %tmp122 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_55", align 8 1865 %tmp123 = bitcast %struct._class_t* %tmp113 to i8* 1866 %call12414 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp123, i8* %tmp122, %1* %tmp114, i64 258, i8* %call12113) 1867 %tmp23 = call i8* @objc_retain(i8* %call12414) nounwind 1868 %tmp25 = call i8* @objc_autorelease(i8* %tmp23) nounwind 1869 %tmp28 = bitcast i8* %tmp25 to %4* 1870 store %4* %tmp28, %4** %err, align 8 1871 br label %if.end125 1872 1873 if.end125: ; preds = %if.then112, %if.then109 1874 %tmp127 = phi %4* [ %tmp110, %if.then109 ], [ %tmp28, %if.then112 ] 1875 %tmp126 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_56", align 8 1876 %tmp128 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_58", align 8 1877 %tmp129 = bitcast %struct._class_t* %tmp126 to i8* 1878 %call13015 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp129, i8* %tmp128, %4* %tmp127) 1879 %tmp131 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_60", align 8 1880 %call13317 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call13015, i8* %tmp131) 1881 br label %end 1882 1883 end: ; preds = %if.end125, %if.end106, %if.end, %land.lhs.true, %entry 1884 %filename.2 = phi %1* [ %filename.0, %if.end106 ], [ %filename.0, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ] 1885 %origFilename.0 = phi %1* [ %tmp, %if.end106 ], [ %tmp, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ] 1886 %url.2 = phi %5* [ %tmp20, %if.end106 ], [ %url.129, %if.end125 ], [ null, %land.lhs.true ], [ null, %entry ], [ %tmp13, %if.end ] 1887 call void @objc_release(i8* %tmp9) nounwind, !clang.imprecise_release !0 1888 %tmp29 = bitcast %5* %url.2 to i8* 1889 call void @objc_release(i8* %tmp29) nounwind, !clang.imprecise_release !0 1890 %tmp30 = bitcast %1* %origFilename.0 to i8* 1891 call void @objc_release(i8* %tmp30) nounwind, !clang.imprecise_release !0 1892 %tmp31 = bitcast %1* %filename.2 to i8* 1893 call void @objc_release(i8* %tmp31) nounwind, !clang.imprecise_release !0 1894 call void @objc_release(i8* %tmp7) nounwind, !clang.imprecise_release !0 1895 ret void 1896 } 1897 1898 !0 = metadata !{} 1899
