test/Transforms/ObjCARC/basic.ll

   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: @callee
 357 ; CHECK: @use_pointer
 358 ; CHECK: @objc_release
 359 ; CHECK: }
 360 define void @test10(i8* %x) nounwind {
 361 entry:
 362   %0 = call i8* @objc_retain(i8* %x) nounwind
 363   call void @callee()
 364   call void @use_pointer(i8* %x)
 365   call void @objc_release(i8* %0) nounwind
 366   ret void
 367 }
 368
 369 ; Trivial retain+autoreleaserelease pair. Don't delete!
 370 ; Also, add a tail keyword, since objc_retain can never be passed
 371 ; a stack argument.
 372
 373 ; CHECK: define void @test11(
 374 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind
 375 ; CHECK: tail call i8* @objc_autorelease(i8* %0) nounwind
 376 ; CHECK: }
 377 define void @test11(i8* %x) nounwind {
 378 entry:
 379   %0 = call i8* @objc_retain(i8* %x) nounwind
 380   call i8* @objc_autorelease(i8* %0) nounwind
 381   call void @use_pointer(i8* %x)
 382   ret void
 383 }
 384
 385 ; Same as test11 but with no use_pointer call. Delete the pair!
 386
 387 ; CHECK: define void @test11a(
 388 ; CHECK: entry:
 389 ; CHECK-NEXT: ret void
 390 ; CHECK: }
 391 define void @test11a(i8* %x) nounwind {
 392 entry:
 393   %0 = call i8* @objc_retain(i8* %x) nounwind
 394   call i8* @objc_autorelease(i8* %0) nounwind
 395   ret void
 396 }
 397
 398 ; Same as test11 but the value is returned. Do an RV optimization.
 399
 400 ; CHECK: define i8* @test11b(
 401 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind
 402 ; CHECK: tail call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind
 403 ; CHECK: }
 404 define i8* @test11b(i8* %x) nounwind {
 405 entry:
 406   %0 = call i8* @objc_retain(i8* %x) nounwind
 407   call i8* @objc_autorelease(i8* %0) nounwind
 408   ret i8* %x
 409 }
 410
 411 ; Trivial retain,release pair with intervening call, but it's dominated
 412 ; by another retain - delete!
 413
 414 ; CHECK: define void @test12(
 415 ; CHECK-NEXT: entry:
 416 ; CHECK-NEXT: @objc_retain(i8* %x)
 417 ; CHECK-NOT: @objc_
 418 ; CHECK: }
 419 define void @test12(i8* %x, i64 %n) {
 420 entry:
 421   call i8* @objc_retain(i8* %x) nounwind
 422   call i8* @objc_retain(i8* %x) nounwind
 423   call void @use_pointer(i8* %x)
 424   call void @use_pointer(i8* %x)
 425   call void @objc_release(i8* %x) nounwind
 426   ret void
 427 }
 428
 429 ; Trivial retain,autorelease pair. Don't delete!
 430
 431 ; CHECK: define void @test13(
 432 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind
 433 ; CHECK: tail call i8* @objc_retain(i8* %x) nounwind
 434 ; CHECK: @use_pointer(i8* %x)
 435 ; CHECK: tail call i8* @objc_autorelease(i8* %x) nounwind
 436 ; CHECK: }
 437 define void @test13(i8* %x, i64 %n) {
 438 entry:
 439   call i8* @objc_retain(i8* %x) nounwind
 440   call i8* @objc_retain(i8* %x) nounwind
 441   call void @use_pointer(i8* %x)
 442   call i8* @objc_autorelease(i8* %x) nounwind
 443   ret void
 444 }
 445
 446 ; Delete the retain+release pair.
 447
 448 ; CHECK: define void @test13b
 449 ; CHECK-NEXT: entry:
 450 ; CHECK-NEXT: @objc_retain(i8* %x)
 451 ; CHECK-NEXT: @use_pointer
 452 ; CHECK-NEXT: @use_pointer
 453 ; CHECK-NEXT: ret void
 454 define void @test13b(i8* %x, i64 %n) {
 455 entry:
 456   call i8* @objc_retain(i8* %x) nounwind
 457   call i8* @objc_retain(i8* %x) nounwind
 458   call void @use_pointer(i8* %x)
 459   call void @use_pointer(i8* %x)
 460   call void @objc_release(i8* %x) nounwind
 461   ret void
 462 }
 463
 464 ; Don't delete the retain+release pair because there's an
 465 ; autoreleasePoolPop in the way.
 466
 467 ; CHECK: define void @test13c
 468 ; CHECK: @objc_retain(i8* %x)
 469 ; CHECK: @objc_autoreleasePoolPop
 470 ; CHECK: @objc_retain(i8* %x)
 471 ; CHECK: @use_pointer
 472 ; CHECK: @objc_release
 473 ; CHECK: }
 474 define void @test13c(i8* %x, i64 %n) {
 475 entry:
 476   call i8* @objc_retain(i8* %x) nounwind
 477   call void @objc_autoreleasePoolPop(i8* undef)
 478   call i8* @objc_retain(i8* %x) nounwind
 479   call void @use_pointer(i8* %x)
 480   call void @use_pointer(i8* %x)
 481   call void @objc_release(i8* %x) nounwind
 482   ret void
 483 }
 484
 485 ; Like test13c, but there's an autoreleasePoolPush in the way, but that
 486 ; doesn't matter.
 487
 488 ; CHECK: define void @test13d
 489 ; CHECK-NEXT: entry:
 490 ; CHECK-NEXT: @objc_retain(i8* %x)
 491 ; CHECK-NEXT: @objc_autoreleasePoolPush
 492 ; CHECK-NEXT: @use_pointer
 493 ; CHECK-NEXT: @use_pointer
 494 ; CHECK-NEXT: ret void
 495 define void @test13d(i8* %x, i64 %n) {
 496 entry:
 497   call i8* @objc_retain(i8* %x) nounwind
 498   call void @objc_autoreleasePoolPush()
 499   call i8* @objc_retain(i8* %x) nounwind
 500   call void @use_pointer(i8* %x)
 501   call void @use_pointer(i8* %x)
 502   call void @objc_release(i8* %x) nounwind
 503   ret void
 504 }
 505
 506 ; Trivial retain,release pair with intervening call, but it's post-dominated
 507 ; by another release - delete!
 508
 509 ; CHECK: define void @test14(
 510 ; CHECK-NEXT: entry:
 511 ; CHECK-NEXT: @use_pointer
 512 ; CHECK-NEXT: @use_pointer
 513 ; CHECK-NEXT: @objc_release
 514 ; CHECK-NEXT: ret void
 515 ; CHECK-NEXT: }
 516 define void @test14(i8* %x, i64 %n) {
 517 entry:
 518   call i8* @objc_retain(i8* %x) nounwind
 519   call void @use_pointer(i8* %x)
 520   call void @use_pointer(i8* %x)
 521   call void @objc_release(i8* %x) nounwind
 522   call void @objc_release(i8* %x) nounwind
 523   ret void
 524 }
 525
 526 ; Trivial retain,autorelease pair with intervening call, but it's post-dominated
 527 ; by another release. Don't delete anything.
 528
 529 ; CHECK: define void @test15(
 530 ; CHECK-NEXT: entry:
 531 ; CHECK-NEXT: @objc_retain(i8* %x)
 532 ; CHECK-NEXT: @use_pointer
 533 ; CHECK-NEXT: @objc_autorelease(i8* %x)
 534 ; CHECK-NEXT: @objc_release
 535 ; CHECK-NEXT: ret void
 536 ; CHECK-NEXT: }
 537 define void @test15(i8* %x, i64 %n) {
 538 entry:
 539   call i8* @objc_retain(i8* %x) nounwind
 540   call void @use_pointer(i8* %x)
 541   call i8* @objc_autorelease(i8* %x) nounwind
 542   call void @objc_release(i8* %x) nounwind
 543   ret void
 544 }
 545
 546 ; Trivial retain,autorelease pair, post-dominated
 547 ; by another release. Delete the retain and release.
 548
 549 ; CHECK: define void @test15b
 550 ; CHECK-NEXT: entry:
 551 ; CHECK-NEXT: @objc_autorelease
 552 ; CHECK-NEXT: ret void
 553 ; CHECK-NEXT: }
 554 define void @test15b(i8* %x, i64 %n) {
 555 entry:
 556   call i8* @objc_retain(i8* %x) nounwind
 557   call i8* @objc_autorelease(i8* %x) nounwind
 558   call void @objc_release(i8* %x) nounwind
 559   ret void
 560 }
 561
 562 ; Retain+release pairs in diamonds, all dominated by a retain.
 563
 564 ; CHECK: define void @test16(
 565 ; CHECK: @objc_retain(i8* %x)
 566 ; CHECK-NOT: @objc
 567 ; CHECK: }
 568 define void @test16(i1 %a, i1 %b, i8* %x) {
 569 entry:
 570   call i8* @objc_retain(i8* %x) nounwind
 571   br i1 %a, label %red, label %orange
 572
 573 red:
 574   call i8* @objc_retain(i8* %x) nounwind
 575   br label %yellow
 576
 577 orange:
 578   call i8* @objc_retain(i8* %x) nounwind
 579   br label %yellow
 580
 581 yellow:
 582   call void @use_pointer(i8* %x)
 583   call void @use_pointer(i8* %x)
 584   br i1 %b, label %green, label %blue
 585
 586 green:
 587   call void @objc_release(i8* %x) nounwind
 588   br label %purple
 589
 590 blue:
 591   call void @objc_release(i8* %x) nounwind
 592   br label %purple
 593
 594 purple:
 595   ret void
 596 }
 597
 598 ; Retain+release pairs in diamonds, all post-dominated by a release.
 599
 600 ; CHECK: define void @test17(
 601 ; CHECK-NOT: @objc_
 602 ; CHECK: purple:
 603 ; CHECK: @objc_release
 604 ; CHECK: }
 605 define void @test17(i1 %a, i1 %b, i8* %x) {
 606 entry:
 607   br i1 %a, label %red, label %orange
 608
 609 red:
 610   call i8* @objc_retain(i8* %x) nounwind
 611   br label %yellow
 612
 613 orange:
 614   call i8* @objc_retain(i8* %x) nounwind
 615   br label %yellow
 616
 617 yellow:
 618   call void @use_pointer(i8* %x)
 619   call void @use_pointer(i8* %x)
 620   br i1 %b, label %green, label %blue
 621
 622 green:
 623   call void @objc_release(i8* %x) nounwind
 624   br label %purple
 625
 626 blue:
 627   call void @objc_release(i8* %x) nounwind
 628   br label %purple
 629
 630 purple:
 631   call void @objc_release(i8* %x) nounwind
 632   ret void
 633 }
 634
 635 ; Delete no-ops.
 636
 637 ; CHECK: define void @test18(
 638 ; CHECK-NOT: @objc_
 639 ; CHECK: }
 640 define void @test18() {
 641   call i8* @objc_retain(i8* null)
 642   call void @objc_release(i8* null)
 643   call i8* @objc_autorelease(i8* null)
 644   ret void
 645 }
 646
 647 ; Delete no-ops where undef can be assumed to be null.
 648
 649 ; CHECK: define void @test18b
 650 ; CHECK-NOT: @objc_
 651 ; CHECK: }
 652 define void @test18b() {
 653   call i8* @objc_retain(i8* undef)
 654   call void @objc_release(i8* undef)
 655   call i8* @objc_autorelease(i8* undef)
 656   ret void
 657 }
 658
 659 ; Replace uses of arguments with uses of return values, to reduce
 660 ; register pressure.
 661
 662 ; CHECK: define void @test19(i32* %y) {
 663 ; CHECK:   %z = bitcast i32* %y to i8*
 664 ; CHECK:   %0 = bitcast i32* %y to i8*
 665 ; CHECK:   %1 = tail call i8* @objc_retain(i8* %0)
 666 ; CHECK:   call void @use_pointer(i8* %z)
 667 ; CHECK:   call void @use_pointer(i8* %z)
 668 ; CHECK:   %2 = bitcast i32* %y to i8*
 669 ; CHECK:   call void @objc_release(i8* %2)
 670 ; CHECK:   ret void
 671 ; CHECK: }
 672 define void @test19(i32* %y) {
 673 entry:
 674   %x = bitcast i32* %y to i8*
 675   %0 = call i8* @objc_retain(i8* %x) nounwind
 676   %z = bitcast i32* %y to i8*
 677   call void @use_pointer(i8* %z)
 678   call void @use_pointer(i8* %z)
 679   call void @objc_release(i8* %x)
 680   ret void
 681 }
 682
 683 ; Bitcast insertion
 684
 685 ; CHECK: define void @test20(
 686 ; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) nounwind
 687 ; CHECK-NEXT: invoke
 688 define void @test20(double* %self) {
 689 if.then12:
 690   %tmp = bitcast double* %self to i8*
 691   %tmp1 = call i8* @objc_retain(i8* %tmp) nounwind
 692   invoke void @invokee()
 693           to label %invoke.cont23 unwind label %lpad20
 694
 695 invoke.cont23:                                    ; preds = %if.then12
 696   invoke void @invokee()
 697           to label %if.end unwind label %lpad20
 698
 699 lpad20:                                           ; preds = %invoke.cont23, %if.then12
 700   %tmp502 = phi double* [ undef, %invoke.cont23 ], [ %self, %if.then12 ]
 701   %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
 702            cleanup
 703   unreachable
 704
 705 if.end:                                           ; preds = %invoke.cont23
 706   ret void
 707 }
 708
 709 ; Delete a redundant retain,autorelease when forwaring a call result
 710 ; directly to a return value.
 711
 712 ; CHECK: define i8* @test21(
 713 ; CHECK: call i8* @returner()
 714 ; CHECK-NEXT: ret i8* %call
 715 define i8* @test21() {
 716 entry:
 717   %call = call i8* @returner()
 718   %0 = call i8* @objc_retain(i8* %call) nounwind
 719   %1 = call i8* @objc_autorelease(i8* %0) nounwind
 720   ret i8* %1
 721 }
 722
 723 ; Move an objc call up through a phi that has null operands.
 724
 725 ; CHECK: define void @test22(
 726 ; CHECK: B:
 727 ; CHECK:   %1 = bitcast double* %p to i8*
 728 ; CHECK:   call void @objc_release(i8* %1)
 729 ; CHECK:   br label %C
 730 ; CHECK: C:                                                ; preds = %B, %A
 731 ; CHECK-NOT: @objc_release
 732 ; CHECK: }
 733 define void @test22(double* %p, i1 %a) {
 734   br i1 %a, label %A, label %B
 735 A:
 736   br label %C
 737 B:
 738   br label %C
 739 C:
 740   %h = phi double* [ null, %A ], [ %p, %B ]
 741   %c = bitcast double* %h to i8*
 742   call void @objc_release(i8* %c)
 743   ret void
 744 }
 745
 746 ; Optimize objc_retainBlock.
 747
 748 ; CHECK: define void @test23(
 749 ; CHECK-NOT: @objc_
 750 ; CHECK: }
 751 %block0 = type { i64, i64, i8*, i8* }
 752 %block1 = type { i8**, i32, i32, i32 (%struct.__block_literal_1*)*, %block0* }
 753 %struct.__block_descriptor = type { i64, i64 }
 754 %struct.__block_literal_1 = type { i8**, i32, i32, i8**, %struct.__block_descriptor* }
 755 @__block_holder_tmp_1 = external constant %block1
 756 define void @test23() {
 757 entry:
 758   %0 = call i8* @objc_retainBlock(i8* bitcast (%block1* @__block_holder_tmp_1 to i8*)) nounwind
 759   call void @bar(i32 ()* bitcast (%block1* @__block_holder_tmp_1 to i32 ()*))
 760   call void @bar(i32 ()* bitcast (%block1* @__block_holder_tmp_1 to i32 ()*))
 761   call void @objc_release(i8* bitcast (%block1* @__block_holder_tmp_1 to i8*)) nounwind
 762   ret void
 763 }
 764
 765 ; Don't optimize objc_retainBlock.
 766
 767 ; CHECK: define void @test23b
 768 ; CHECK: @objc_retainBlock
 769 ; CHECK: @objc_release
 770 ; CHECK: }
 771 define void @test23b(i8* %p) {
 772 entry:
 773   %0 = call i8* @objc_retainBlock(i8* %p) nounwind
 774   call void @callee()
 775   call void @use_pointer(i8* %p)
 776   call void @objc_release(i8* %p) nounwind
 777   ret void
 778 }
 779
 780 ; Any call can decrement a retain count.
 781
 782 ; CHECK: define void @test24(
 783 ; CHECK: @objc_retain(i8* %a)
 784 ; CHECK: @objc_release
 785 ; CHECK: }
 786 define void @test24(i8* %r, i8* %a) {
 787   call i8* @objc_retain(i8* %a)
 788   call void @use_pointer(i8* %r)
 789   %q = load i8* %a
 790   call void @objc_release(i8* %a)
 791   ret void
 792 }
 793
 794 ; Don't move a retain/release pair if the release can be moved
 795 ; but the retain can't be moved to balance it.
 796
 797 ; CHECK: define void @test25(
 798 ; CHECK: entry:
 799 ; CHECK:   call i8* @objc_retain(i8* %p)
 800 ; CHECK: true:
 801 ; CHECK: done:
 802 ; CHECK:   call void @objc_release(i8* %p)
 803 ; CHECK: }
 804 define void @test25(i8* %p, i1 %x) {
 805 entry:
 806   %f0 = call i8* @objc_retain(i8* %p)
 807   call void @callee()
 808   br i1 %x, label %true, label %done
 809
 810 true:
 811   store i8 0, i8* %p
 812   br label %done
 813
 814 done:
 815   call void @objc_release(i8* %p)
 816   ret void
 817 }
 818
 819 ; Don't move a retain/release pair if the retain can be moved
 820 ; but the release can't be moved to balance it.
 821
 822 ; CHECK: define void @test26(
 823 ; CHECK: entry:
 824 ; CHECK:   call i8* @objc_retain(i8* %p)
 825 ; CHECK: true:
 826 ; CHECK: done:
 827 ; CHECK:   call void @objc_release(i8* %p)
 828 ; CHECK: }
 829 define void @test26(i8* %p, i1 %x) {
 830 entry:
 831   %f0 = call i8* @objc_retain(i8* %p)
 832   br i1 %x, label %true, label %done
 833
 834 true:
 835   call void @callee()
 836   br label %done
 837
 838 done:
 839   store i8 0, i8* %p
 840   call void @objc_release(i8* %p)
 841   ret void
 842 }
 843
 844 ; Don't sink the retain,release into the loop.
 845
 846 ; CHECK: define void @test27(
 847 ; CHECK: entry:
 848 ; CHECK: call i8* @objc_retain(i8* %p)
 849 ; CHECK: loop:
 850 ; CHECK-NOT: @objc_
 851 ; CHECK: done:
 852 ; CHECK: call void @objc_release
 853 ; CHECK: }
 854 define void @test27(i8* %p, i1 %x, i1 %y) {
 855 entry:
 856   %f0 = call i8* @objc_retain(i8* %p)
 857   br i1 %x, label %loop, label %done
 858
 859 loop:
 860   call void @callee()
 861   store i8 0, i8* %p
 862   br i1 %y, label %done, label %loop
 863
 864 done:
 865   call void @objc_release(i8* %p)
 866   ret void
 867 }
 868
 869 ; Trivial code motion case: Triangle.
 870
 871 ; CHECK: define void @test28(
 872 ; CHECK-NOT: @objc_
 873 ; CHECK: true:
 874 ; CHECK: call i8* @objc_retain(
 875 ; CHECK: call void @callee()
 876 ; CHECK: store
 877 ; CHECK: call void @objc_release
 878 ; CHECK: done:
 879 ; CHECK-NOT: @objc_
 880 ; CHECK: }
 881 define void @test28(i8* %p, i1 %x) {
 882 entry:
 883   %f0 = call i8* @objc_retain(i8* %p)
 884   br i1 %x, label %true, label %done
 885
 886 true:
 887   call void @callee()
 888   store i8 0, i8* %p
 889   br label %done
 890
 891 done:
 892   call void @objc_release(i8* %p), !clang.imprecise_release !0
 893   ret void
 894 }
 895
 896 ; Trivial code motion case: Triangle, but no metadata. Don't move past
 897 ; unrelated memory references!
 898
 899 ; CHECK: define void @test28b
 900 ; CHECK: call i8* @objc_retain(
 901 ; CHECK: true:
 902 ; CHECK-NOT: @objc_
 903 ; CHECK: call void @callee()
 904 ; CHECK-NOT: @objc_
 905 ; CHECK: store
 906 ; CHECK-NOT: @objc_
 907 ; CHECK: done:
 908 ; CHECK: @objc_release
 909 ; CHECK: }
 910 define void @test28b(i8* %p, i1 %x, i8* noalias %t) {
 911 entry:
 912   %f0 = call i8* @objc_retain(i8* %p)
 913   br i1 %x, label %true, label %done
 914
 915 true:
 916   call void @callee()
 917   store i8 0, i8* %p
 918   br label %done
 919
 920 done:
 921   store i8 0, i8* %t
 922   call void @objc_release(i8* %p)
 923   ret void
 924 }
 925
 926 ; Trivial code motion case: Triangle, with metadata. Do move past
 927 ; unrelated memory references! And preserve the metadata.
 928
 929 ; CHECK: define void @test28c
 930 ; CHECK-NOT: @objc_
 931 ; CHECK: true:
 932 ; CHECK: call i8* @objc_retain(
 933 ; CHECK: call void @callee()
 934 ; CHECK: store
 935 ; CHECK: call void @objc_release(i8* %p) nounwind, !clang.imprecise_release
 936 ; CHECK: done:
 937 ; CHECK-NOT: @objc_
 938 ; CHECK: }
 939 define void @test28c(i8* %p, i1 %x, i8* noalias %t) {
 940 entry:
 941   %f0 = call i8* @objc_retain(i8* %p)
 942   br i1 %x, label %true, label %done
 943
 944 true:
 945   call void @callee()
 946   store i8 0, i8* %p
 947   br label %done
 948
 949 done:
 950   store i8 0, i8* %t
 951   call void @objc_release(i8* %p), !clang.imprecise_release !0
 952   ret void
 953 }
 954
 955 ; Like test28. but with two releases.
 956
 957 ; CHECK: define void @test29(
 958 ; CHECK-NOT: @objc_
 959 ; CHECK: true:
 960 ; CHECK: call i8* @objc_retain(
 961 ; CHECK: call void @callee()
 962 ; CHECK: store
 963 ; CHECK: call void @objc_release
 964 ; CHECK-NOT: @objc_release
 965 ; CHECK: done:
 966 ; CHECK-NOT: @objc_
 967 ; CHECK: ohno:
 968 ; CHECK-NOT: @objc_
 969 ; CHECK: }
 970 define void @test29(i8* %p, i1 %x, i1 %y) {
 971 entry:
 972   %f0 = call i8* @objc_retain(i8* %p)
 973   br i1 %x, label %true, label %done
 974
 975 true:
 976   call void @callee()
 977   store i8 0, i8* %p
 978   br i1 %y, label %done, label %ohno
 979
 980 done:
 981   call void @objc_release(i8* %p)
 982   ret void
 983
 984 ohno:
 985   call void @objc_release(i8* %p)
 986   ret void
 987 }
 988
 989 ; Basic case with the use and call in a diamond
 990 ; with an extra release.
 991
 992 ; CHECK: define void @test30(
 993 ; CHECK-NOT: @objc_
 994 ; CHECK: true:
 995 ; CHECK: call i8* @objc_retain(
 996 ; CHECK: call void @callee()
 997 ; CHECK: store
 998 ; CHECK: call void @objc_release
 999 ; CHECK-NOT: @objc_release
1000 ; CHECK: false:
1001 ; CHECK-NOT: @objc_
1002 ; CHECK: done:
1003 ; CHECK-NOT: @objc_
1004 ; CHECK: ohno:
1005 ; CHECK-NOT: @objc_
1006 ; CHECK: }
1007 define void @test30(i8* %p, i1 %x, i1 %y, i1 %z) {
1008 entry:
1009   %f0 = call i8* @objc_retain(i8* %p)
1010   br i1 %x, label %true, label %false
1011
1012 true:
1013   call void @callee()
1014   store i8 0, i8* %p
1015   br i1 %y, label %done, label %ohno
1016
1017 false:
1018   br i1 %z, label %done, label %ohno
1019
1020 done:
1021   call void @objc_release(i8* %p)
1022   ret void
1023
1024 ohno:
1025   call void @objc_release(i8* %p)
1026   ret void
1027 }
1028
1029 ; Basic case with a mergeable release.
1030
1031 ; CHECK: define void @test31(
1032 ; CHECK: call i8* @objc_retain(i8* %p)
1033 ; CHECK: call void @callee()
1034 ; CHECK: store
1035 ; CHECK: call void @objc_release
1036 ; CHECK-NOT: @objc_release
1037 ; CHECK: true:
1038 ; CHECK-NOT: @objc_release
1039 ; CHECK: false:
1040 ; CHECK-NOT: @objc_release
1041 ; CHECK: ret void
1042 ; CHECK-NOT: @objc_release
1043 ; CHECK: }
1044 define void @test31(i8* %p, i1 %x) {
1045 entry:
1046   %f0 = call i8* @objc_retain(i8* %p)
1047   call void @callee()
1048   store i8 0, i8* %p
1049   br i1 %x, label %true, label %false
1050 true:
1051   call void @objc_release(i8* %p)
1052   ret void
1053 false:
1054   call void @objc_release(i8* %p)
1055   ret void
1056 }
1057
1058 ; Don't consider bitcasts or getelementptrs direct uses.
1059
1060 ; CHECK: define void @test32(
1061 ; CHECK-NOT: @objc_
1062 ; CHECK: true:
1063 ; CHECK: call i8* @objc_retain(
1064 ; CHECK: call void @callee()
1065 ; CHECK: store
1066 ; CHECK: call void @objc_release
1067 ; CHECK: done:
1068 ; CHECK-NOT: @objc_
1069 ; CHECK: }
1070 define void @test32(i8* %p, i1 %x) {
1071 entry:
1072   %f0 = call i8* @objc_retain(i8* %p)
1073   br i1 %x, label %true, label %done
1074
1075 true:
1076   call void @callee()
1077   store i8 0, i8* %p
1078   br label %done
1079
1080 done:
1081   %g = bitcast i8* %p to i8*
1082   %h = getelementptr i8* %g, i64 0
1083   call void @objc_release(i8* %g)
1084   ret void
1085 }
1086
1087 ; Do consider icmps to be direct uses.
1088
1089 ; CHECK: define void @test33(
1090 ; CHECK-NOT: @objc_
1091 ; CHECK: true:
1092 ; CHECK: call i8* @objc_retain(
1093 ; CHECK: call void @callee()
1094 ; CHECK: icmp
1095 ; CHECK: call void @objc_release
1096 ; CHECK: done:
1097 ; CHECK-NOT: @objc_
1098 ; CHECK: }
1099 define void @test33(i8* %p, i1 %x, i8* %y) {
1100 entry:
1101   %f0 = call i8* @objc_retain(i8* %p)
1102   br i1 %x, label %true, label %done
1103
1104 true:
1105   call void @callee()
1106   %v = icmp eq i8* %p, %y
1107   br label %done
1108
1109 done:
1110   %g = bitcast i8* %p to i8*
1111   %h = getelementptr i8* %g, i64 0
1112   call void @objc_release(i8* %g)
1113   ret void
1114 }
1115
1116 ; Delete retain,release if there's just a possible dec.
1117
1118 ; CHECK: define void @test34(
1119 ; CHECK-NOT: @objc_
1120 ; CHECK: }
1121 define void @test34(i8* %p, i1 %x, i8* %y) {
1122 entry:
1123   %f0 = call i8* @objc_retain(i8* %p)
1124   br i1 %x, label %true, label %done
1125
1126 true:
1127   call void @callee()
1128   br label %done
1129
1130 done:
1131   %g = bitcast i8* %p to i8*
1132   %h = getelementptr i8* %g, i64 0
1133   call void @objc_release(i8* %g)
1134   ret void
1135 }
1136
1137 ; Delete retain,release if there's just a use.
1138
1139 ; CHECK: define void @test35(
1140 ; CHECK-NOT: @objc_
1141 ; CHECK: }
1142 define void @test35(i8* %p, i1 %x, i8* %y) {
1143 entry:
1144   %f0 = call i8* @objc_retain(i8* %p)
1145   br i1 %x, label %true, label %done
1146
1147 true:
1148   %v = icmp eq i8* %p, %y
1149   br label %done
1150
1151 done:
1152   %g = bitcast i8* %p to i8*
1153   %h = getelementptr i8* %g, i64 0
1154   call void @objc_release(i8* %g)
1155   ret void
1156 }
1157
1158 ; Delete a retain,release if there's no actual use.
1159
1160 ; CHECK: define void @test36(
1161 ; CHECK-NOT: @objc_
1162 ; CHECK: call void @callee()
1163 ; CHECK-NOT: @objc_
1164 ; CHECK: call void @callee()
1165 ; CHECK-NOT: @objc_
1166 ; CHECK: }
1167 define void @test36(i8* %p) {
1168 entry:
1169   call i8* @objc_retain(i8* %p)
1170   call void @callee()
1171   call void @callee()
1172   call void @objc_release(i8* %p)
1173   ret void
1174 }
1175
1176 ; Like test36, but with metadata.
1177
1178 ; CHECK: define void @test37(
1179 ; CHECK-NOT: @objc_
1180 ; CHECK: }
1181 define void @test37(i8* %p) {
1182 entry:
1183   call i8* @objc_retain(i8* %p)
1184   call void @callee()
1185   call void @callee()
1186   call void @objc_release(i8* %p), !clang.imprecise_release !0
1187   ret void
1188 }
1189
1190 ; Be aggressive about analyzing phis to eliminate possible uses.
1191
1192 ; CHECK: define void @test38(
1193 ; CHECK-NOT: @objc_
1194 ; CHECK: }
1195 define void @test38(i8* %p, i1 %u, i1 %m, i8* %z, i8* %y, i8* %x, i8* %w) {
1196 entry:
1197   call i8* @objc_retain(i8* %p)
1198   br i1 %u, label %true, label %false
1199 true:
1200   br i1 %m, label %a, label %b
1201 false:
1202   br i1 %m, label %c, label %d
1203 a:
1204   br label %e
1205 b:
1206   br label %e
1207 c:
1208   br label %f
1209 d:
1210   br label %f
1211 e:
1212   %j = phi i8* [ %z, %a ], [ %y, %b ]
1213   br label %g
1214 f:
1215   %k = phi i8* [ %w, %c ], [ %x, %d ]
1216   br label %g
1217 g:
1218   %h = phi i8* [ %j, %e ], [ %k, %f ]
1219   call void @use_pointer(i8* %h)
1220   call void @objc_release(i8* %p), !clang.imprecise_release !0
1221   ret void
1222 }
1223
1224 ; Delete retain,release pairs around loops.
1225
1226 ; CHECK: define void @test39(
1227 ; CHECK_NOT: @objc_
1228 ; CHECK: }
1229 define void @test39(i8* %p) {
1230 entry:
1231   %0 = call i8* @objc_retain(i8* %p)
1232   br label %loop
1233
1234 loop:                                             ; preds = %loop, %entry
1235   br i1 undef, label %loop, label %exit
1236
1237 exit:                                             ; preds = %loop
1238   call void @objc_release(i8* %0), !clang.imprecise_release !0
1239   ret void
1240 }
1241
1242 ; Delete retain,release pairs around loops containing uses.
1243
1244 ; CHECK: define void @test39b(
1245 ; CHECK_NOT: @objc_
1246 ; CHECK: }
1247 define void @test39b(i8* %p) {
1248 entry:
1249   %0 = call i8* @objc_retain(i8* %p)
1250   br label %loop
1251
1252 loop:                                             ; preds = %loop, %entry
1253   store i8 0, i8* %0
1254   br i1 undef, label %loop, label %exit
1255
1256 exit:                                             ; preds = %loop
1257   call void @objc_release(i8* %0), !clang.imprecise_release !0
1258   ret void
1259 }
1260
1261 ; Delete retain,release pairs around loops containing potential decrements.
1262
1263 ; CHECK: define void @test39c(
1264 ; CHECK_NOT: @objc_
1265 ; CHECK: }
1266 define void @test39c(i8* %p) {
1267 entry:
1268   %0 = call i8* @objc_retain(i8* %p)
1269   br label %loop
1270
1271 loop:                                             ; preds = %loop, %entry
1272   call void @use_pointer(i8* %0)
1273   br i1 undef, label %loop, label %exit
1274
1275 exit:                                             ; preds = %loop
1276   call void @objc_release(i8* %0), !clang.imprecise_release !0
1277   ret void
1278 }
1279
1280 ; Delete retain,release pairs around loops even if
1281 ; the successors are in a different order.
1282
1283 ; CHECK: define void @test40(
1284 ; CHECK_NOT: @objc_
1285 ; CHECK: }
1286 define void @test40(i8* %p) {
1287 entry:
1288   %0 = call i8* @objc_retain(i8* %p)
1289   br label %loop
1290
1291 loop:                                             ; preds = %loop, %entry
1292   call void @use_pointer(i8* %0)
1293   br i1 undef, label %exit, label %loop
1294
1295 exit:                                             ; preds = %loop
1296   call void @objc_release(i8* %0), !clang.imprecise_release !0
1297   ret void
1298 }
1299
1300 ; Do the known-incremented retain+release elimination even if the pointer
1301 ; is also autoreleased.
1302
1303 ; CHECK: define void @test42(
1304 ; CHECK-NEXT: entry:
1305 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1306 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1307 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1308 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1309 ; CHECK-NEXT: ret void
1310 ; CHECK-NEXT: }
1311 define void @test42(i8* %p) {
1312 entry:
1313   call i8* @objc_retain(i8* %p)
1314   call i8* @objc_autorelease(i8* %p)
1315   call i8* @objc_retain(i8* %p)
1316   call void @use_pointer(i8* %p)
1317   call void @use_pointer(i8* %p)
1318   call void @objc_release(i8* %p)
1319   ret void
1320 }
1321
1322 ; Don't the known-incremented retain+release elimination if the pointer is
1323 ; autoreleased and there's an autoreleasePoolPop.
1324
1325 ; CHECK: define void @test43(
1326 ; CHECK-NEXT: entry:
1327 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1328 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1329 ; CHECK-NEXT: call i8* @objc_retain
1330 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1331 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1332 ; CHECK-NEXT: call void @objc_autoreleasePoolPop(i8* undef)
1333 ; CHECK-NEXT: call void @objc_release
1334 ; CHECK-NEXT: ret void
1335 ; CHECK-NEXT: }
1336 define void @test43(i8* %p) {
1337 entry:
1338   call i8* @objc_retain(i8* %p)
1339   call i8* @objc_autorelease(i8* %p)
1340   call i8* @objc_retain(i8* %p)
1341   call void @use_pointer(i8* %p)
1342   call void @use_pointer(i8* %p)
1343   call void @objc_autoreleasePoolPop(i8* undef)
1344   call void @objc_release(i8* %p)
1345   ret void
1346 }
1347
1348 ; Do the known-incremented retain+release elimination if the pointer is
1349 ; autoreleased and there's an autoreleasePoolPush.
1350
1351 ; CHECK: define void @test43b
1352 ; CHECK-NEXT: entry:
1353 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1354 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1355 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1356 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1357 ; CHECK-NEXT: call void @objc_autoreleasePoolPush()
1358 ; CHECK-NEXT: ret void
1359 ; CHECK-NEXT: }
1360 define void @test43b(i8* %p) {
1361 entry:
1362   call i8* @objc_retain(i8* %p)
1363   call i8* @objc_autorelease(i8* %p)
1364   call i8* @objc_retain(i8* %p)
1365   call void @use_pointer(i8* %p)
1366   call void @use_pointer(i8* %p)
1367   call void @objc_autoreleasePoolPush()
1368   call void @objc_release(i8* %p)
1369   ret void
1370 }
1371
1372 ; Do retain+release elimination for non-provenance pointers.
1373
1374 ; CHECK: define void @test44(
1375 ; CHECK-NOT: objc_
1376 ; CHECK: }
1377 define void @test44(i8** %pp) {
1378   %p = load i8** %pp
1379   %q = call i8* @objc_retain(i8* %p)
1380   call void @objc_release(i8* %q)
1381   ret void
1382 }
1383
1384 ; Don't delete retain+release with an unknown-provenance
1385 ; may-alias objc_release between them.
1386
1387 ; CHECK: define void @test45(
1388 ; CHECK: call i8* @objc_retain(i8* %p)
1389 ; CHECK: call void @objc_release(i8* %q)
1390 ; CHECK: call void @use_pointer(i8* %p)
1391 ; CHECK: call void @objc_release(i8* %p)
1392 define void @test45(i8** %pp, i8** %qq) {
1393   %p = load i8** %pp
1394   %q = load i8** %qq
1395   call i8* @objc_retain(i8* %p)
1396   call void @objc_release(i8* %q)
1397   call void @use_pointer(i8* %p)
1398   call void @objc_release(i8* %p)
1399   ret void
1400 }
1401
1402 ; Don't delete retain and autorelease here.
1403
1404 ; CHECK: define void @test46(
1405 ; CHECK: tail call i8* @objc_retain(i8* %p) nounwind
1406 ; CHECK: true:
1407 ; CHECK: tail call i8* @objc_autorelease(i8* %p) nounwind
1408 define void @test46(i8* %p, i1 %a) {
1409 entry:
1410   call i8* @objc_retain(i8* %p)
1411   br i1 %a, label %true, label %false
1412
1413 true:
1414   call i8* @objc_autorelease(i8* %p)
1415   call void @use_pointer(i8* %p)
1416   ret void
1417
1418 false:
1419   ret void
1420 }
1421
1422 ; Delete no-op cast calls.
1423
1424 ; CHECK: define i8* @test47(
1425 ; CHECK-NOT: call
1426 ; CHECK: ret i8* %p
1427 define i8* @test47(i8* %p) nounwind {
1428   %x = call i8* @objc_retainedObject(i8* %p)
1429   ret i8* %x
1430 }
1431
1432 ; Delete no-op cast calls.
1433
1434 ; CHECK: define i8* @test48(
1435 ; CHECK-NOT: call
1436 ; CHECK: ret i8* %p
1437 define i8* @test48(i8* %p) nounwind {
1438   %x = call i8* @objc_unretainedObject(i8* %p)
1439   ret i8* %x
1440 }
1441
1442 ; Delete no-op cast calls.
1443
1444 ; CHECK: define i8* @test49(
1445 ; CHECK-NOT: call
1446 ; CHECK: ret i8* %p
1447 define i8* @test49(i8* %p) nounwind {
1448   %x = call i8* @objc_unretainedPointer(i8* %p)
1449   ret i8* %x
1450 }
1451
1452 ; Do delete retain+release with intervening stores of the
1453 ; address value;
1454
1455 ; CHECK: define void @test50(
1456 ; CHECK-NOT: @objc_
1457 ; CHECK: }
1458 define void @test50(i8* %p, i8** %pp) {
1459   call i8* @objc_retain(i8* %p)
1460   call void @callee()
1461   store i8* %p, i8** %pp
1462   call void @objc_release(i8* %p)
1463   ret void
1464 }
1465
1466 ; Don't delete retain+release with intervening stores through the
1467 ; address value.
1468
1469 ; CHECK: define void @test51(
1470 ; CHECK: call i8* @objc_retain(i8* %p)
1471 ; CHECK: call void @objc_release(i8* %p)
1472 define void @test51(i8* %p) {
1473   call i8* @objc_retain(i8* %p)
1474   call void @callee()
1475   store i8 0, i8* %p
1476   call void @objc_release(i8* %p)
1477   ret void
1478 }
1479
1480 ; Don't delete retain+release with intervening use of a pointer of
1481 ; unknown provenance.
1482
1483 ; CHECK: define void @test52(
1484 ; CHECK: call i8* @objc_retain
1485 ; CHECK: call void @callee()
1486 ; CHECK: call void @use_pointer(i8* %z)
1487 ; CHECK: call void @objc_release
1488 define void @test52(i8** %zz, i8** %pp) {
1489   %p = load i8** %pp
1490   %1 = call i8* @objc_retain(i8* %p)
1491   call void @callee()
1492   %z = load i8** %zz
1493   call void @use_pointer(i8* %z)
1494   call void @objc_release(i8* %p)
1495   ret void
1496 }
1497
1498 ; Like test52, but the pointer has function type, so it's assumed to
1499 ; be not reference counted.
1500
1501 ; CHECK: define void @test53(
1502 ; CHECK-NOT: @objc_
1503 ; CHECK: }
1504 define void @test53(void ()** %zz, i8** %pp) {
1505   %p = load i8** %pp
1506   %1 = call i8* @objc_retain(i8* %p)
1507   call void @callee()
1508   %z = load void ()** %zz
1509   call void @callee_fnptr(void ()* %z)
1510   call void @objc_release(i8* %p)
1511   ret void
1512 }
1513
1514 ; Convert autorelease to release if the value is unused.
1515
1516 ; CHECK: define void @test54(
1517 ; CHECK: call i8* @returner()
1518 ; CHECK-NEXT: call void @objc_release(i8* %t) nounwind, !clang.imprecise_release !0
1519 ; CHECK-NEXT: ret void
1520 define void @test54() {
1521   %t = call i8* @returner()
1522   call i8* @objc_autorelease(i8* %t)
1523   ret void
1524 }
1525
1526 ; Nested retain+release pairs. Delete them both.
1527
1528 ; CHECK: define void @test55(
1529 ; CHECK-NOT: @objc
1530 ; CHECK: }
1531 define void @test55(i8* %x) {
1532 entry:
1533   %0 = call i8* @objc_retain(i8* %x) nounwind
1534   %1 = call i8* @objc_retain(i8* %x) nounwind
1535   call void @objc_release(i8* %x) nounwind
1536   call void @objc_release(i8* %x) nounwind
1537   ret void
1538 }
1539
1540 ; Nested retain+release pairs where the inner pair depends
1541 ; on the outer pair to be removed, and then the outer pair
1542 ; can be partially eliminated. Plus an extra outer pair to
1543 ; eliminate, for fun.
1544
1545 ; CHECK: define void @test56(
1546 ; CHECK-NOT: @objc
1547 ; CHECK: if.then:
1548 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) nounwind
1549 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
1550 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
1551 ; CHECK-NEXT: tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1552 ; CHECK-NEXT: br label %if.end
1553 ; CHECK-NOT: @objc
1554 ; CHECK: }
1555 define void @test56(i8* %x, i32 %n) {
1556 entry:
1557   %0 = tail call i8* @objc_retain(i8* %x) nounwind
1558   %1 = tail call i8* @objc_retain(i8* %0) nounwind
1559   %tobool = icmp eq i32 %n, 0
1560   br i1 %tobool, label %if.end, label %if.then
1561
1562 if.then:                                          ; preds = %entry
1563   %2 = tail call i8* @objc_retain(i8* %1) nounwind
1564   tail call void @use_pointer(i8* %2)
1565   tail call void @use_pointer(i8* %2)
1566   tail call void @objc_release(i8* %2) nounwind, !clang.imprecise_release !0
1567   br label %if.end
1568
1569 if.end:                                           ; preds = %entry, %if.then
1570   tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
1571   tail call void @objc_release(i8* %0) nounwind, !clang.imprecise_release !0
1572   ret void
1573 }
1574
1575 ; When there are adjacent retain+release pairs, the first one is
1576 ; known unnecessary because the presence of the second one means that
1577 ; the first one won't be deleting the object.
1578
1579 ; CHECK:      define void @test57(
1580 ; CHECK-NEXT: entry:
1581 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1582 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1583 ; CHECK-NEXT:   %0 = tail call i8* @objc_retain(i8* %x) nounwind
1584 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1585 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1586 ; CHECK-NEXT:   call void @objc_release(i8* %x) nounwind
1587 ; CHECK-NEXT:   ret void
1588 ; CHECK-NEXT: }
1589 define void @test57(i8* %x) nounwind {
1590 entry:
1591   call i8* @objc_retain(i8* %x) nounwind
1592   call void @use_pointer(i8* %x)
1593   call void @use_pointer(i8* %x)
1594   call void @objc_release(i8* %x) nounwind
1595   call i8* @objc_retain(i8* %x) nounwind
1596   call void @use_pointer(i8* %x)
1597   call void @use_pointer(i8* %x)
1598   call void @objc_release(i8* %x) nounwind
1599   ret void
1600 }
1601
1602 ; An adjacent retain+release pair is sufficient even if it will be
1603 ; removed itself.
1604
1605 ; CHECK:      define void @test58(
1606 ; CHECK-NEXT: entry:
1607 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1608 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1609 ; CHECK-NEXT:   ret void
1610 ; CHECK-NEXT: }
1611 define void @test58(i8* %x) nounwind {
1612 entry:
1613   call i8* @objc_retain(i8* %x) nounwind
1614   call void @use_pointer(i8* %x)
1615   call void @use_pointer(i8* %x)
1616   call void @objc_release(i8* %x) nounwind
1617   call i8* @objc_retain(i8* %x) nounwind
1618   call void @objc_release(i8* %x) nounwind
1619   ret void
1620 }
1621
1622 ; Don't delete the second retain+release pair in an adjacent set.
1623
1624 ; CHECK:      define void @test59(
1625 ; CHECK-NEXT: entry:
1626 ; CHECK-NEXT:   %0 = tail call i8* @objc_retain(i8* %x) nounwind
1627 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1628 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
1629 ; CHECK-NEXT:   call void @objc_release(i8* %x) nounwind
1630 ; CHECK-NEXT:   ret void
1631 ; CHECK-NEXT: }
1632 define void @test59(i8* %x) nounwind {
1633 entry:
1634   %a = call i8* @objc_retain(i8* %x) nounwind
1635   call void @objc_release(i8* %x) nounwind
1636   %b = call i8* @objc_retain(i8* %x) nounwind
1637   call void @use_pointer(i8* %x)
1638   call void @use_pointer(i8* %x)
1639   call void @objc_release(i8* %x) nounwind
1640   ret void
1641 }
1642
1643 ; Constant pointers to objects don't need reference counting.
1644
1645 @constptr = external constant i8*
1646 @something = external global i8*
1647
1648 ; CHECK: define void @test60(
1649 ; CHECK-NOT: @objc_
1650 ; CHECK: }
1651 define void @test60() {
1652   %t = load i8** @constptr
1653   %s = load i8** @something
1654   call i8* @objc_retain(i8* %s)
1655   call void @callee()
1656   call void @use_pointer(i8* %t)
1657   call void @objc_release(i8* %s)
1658   ret void
1659 }
1660
1661 ; Constant pointers to objects don't need to be considered related to other
1662 ; pointers.
1663
1664 ; CHECK: define void @test61(
1665 ; CHECK-NOT: @objc_
1666 ; CHECK: }
1667 define void @test61() {
1668   %t = load i8** @constptr
1669   call i8* @objc_retain(i8* %t)
1670   call void @callee()
1671   call void @use_pointer(i8* %t)
1672   call void @objc_release(i8* %t)
1673   ret void
1674 }
1675
1676 declare void @bar(i32 ()*)
1677
1678 ; A few real-world testcases.
1679
1680 @.str4 = private unnamed_addr constant [33 x i8] c"-[A z] = { %f, %f, { %f, %f } }\0A\00"
1681 @"OBJC_IVAR_$_A.myZ" = global i64 20, section "__DATA, __objc_const", align 8
1682 declare i32 @printf(i8* nocapture, ...) nounwind
1683 declare i32 @puts(i8* nocapture) nounwind
1684 @str = internal constant [16 x i8] c"-[ Top0 _getX ]\00"
1685
1686 ; CHECK: @"\01-[A z]"
1687 ; CHECK-NOT: @objc_
1688 ; CHECK: }
1689
1690 define {<2 x float>, <2 x float>} @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind {
1691 invoke.cont:
1692   %0 = bitcast {}* %self to i8*
1693   %1 = tail call i8* @objc_retain(i8* %0) nounwind
1694   tail call void @llvm.dbg.value(metadata !{{}* %self}, i64 0, metadata !0)
1695   tail call void @llvm.dbg.value(metadata !{{}* %self}, i64 0, metadata !0)
1696   %ivar = load i64* @"OBJC_IVAR_$_A.myZ", align 8
1697   %add.ptr = getelementptr i8* %0, i64 %ivar
1698   %tmp1 = bitcast i8* %add.ptr to float*
1699   %tmp2 = load float* %tmp1, align 4
1700   %conv = fpext float %tmp2 to double
1701   %add.ptr.sum = add i64 %ivar, 4
1702   %tmp6 = getelementptr inbounds i8* %0, i64 %add.ptr.sum
1703   %2 = bitcast i8* %tmp6 to float*
1704   %tmp7 = load float* %2, align 4
1705   %conv8 = fpext float %tmp7 to double
1706   %add.ptr.sum36 = add i64 %ivar, 8
1707   %tmp12 = getelementptr inbounds i8* %0, i64 %add.ptr.sum36
1708   %arrayidx = bitcast i8* %tmp12 to float*
1709   %tmp13 = load float* %arrayidx, align 4
1710   %conv14 = fpext float %tmp13 to double
1711   %tmp12.sum = add i64 %ivar, 12
1712   %arrayidx19 = getelementptr inbounds i8* %0, i64 %tmp12.sum
1713   %3 = bitcast i8* %arrayidx19 to float*
1714   %tmp20 = load float* %3, align 4
1715   %conv21 = fpext float %tmp20 to double
1716   %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)
1717   %ivar23 = load i64* @"OBJC_IVAR_$_A.myZ", align 8
1718   %add.ptr24 = getelementptr i8* %0, i64 %ivar23
1719   %4 = bitcast i8* %add.ptr24 to i128*
1720   %srcval = load i128* %4, align 4
1721   tail call void @objc_release(i8* %0) nounwind
1722   %tmp29 = trunc i128 %srcval to i64
1723   %tmp30 = bitcast i64 %tmp29 to <2 x float>
1724   %tmp31 = insertvalue {<2 x float>, <2 x float>} undef, <2 x float> %tmp30, 0
1725   %tmp32 = lshr i128 %srcval, 64
1726   %tmp33 = trunc i128 %tmp32 to i64
1727   %tmp34 = bitcast i64 %tmp33 to <2 x float>
1728   %tmp35 = insertvalue {<2 x float>, <2 x float>} %tmp31, <2 x float> %tmp34, 1
1729   ret {<2 x float>, <2 x float>} %tmp35
1730 }
1731
1732 ; CHECK: @"\01-[Top0 _getX]"
1733 ; CHECK-NOT: @objc_
1734 ; CHECK: }
1735
1736 define i32 @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) nounwind {
1737 invoke.cont:
1738   %0 = bitcast {}* %self to i8*
1739   %1 = tail call i8* @objc_retain(i8* %0) nounwind
1740   %puts = tail call i32 @puts(i8* getelementptr inbounds ([16 x i8]* @str, i64 0, i64 0))
1741   tail call void @objc_release(i8* %0) nounwind
1742   ret i32 0
1743 }
1744
1745 @"\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"
1746 @"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip"
1747 @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"
1748
1749 ; A simple loop. Eliminate the retain and release inside of it!
1750
1751 ; CHECK: define void @loop
1752 ; CHECK: for.body:
1753 ; CHECK-NOT: @objc_
1754 ; CHECK: @objc_msgSend
1755 ; CHECK-NOT: @objc_
1756 ; CHECK: for.end:
1757 define void @loop(i8* %x, i64 %n) {
1758 entry:
1759   %0 = tail call i8* @objc_retain(i8* %x) nounwind
1760   %cmp9 = icmp sgt i64 %n, 0
1761   br i1 %cmp9, label %for.body, label %for.end
1762
1763 for.body:                                         ; preds = %entry, %for.body
1764   %i.010 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
1765   %1 = tail call i8* @objc_retain(i8* %x) nounwind
1766   %tmp5 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8
1767   %call = tail call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %1, i8* %tmp5)
1768   tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
1769   %inc = add nsw i64 %i.010, 1
1770   %exitcond = icmp eq i64 %inc, %n
1771   br i1 %exitcond, label %for.end, label %for.body
1772
1773 for.end:                                          ; preds = %for.body, %entry
1774   tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1775   ret void
1776 }
1777
1778 ; ObjCARCOpt can delete the retain,release on self.
1779
1780 ; CHECK: define void @TextEditTest
1781 ; CHECK-NOT: call i8* @objc_retain(i8* %tmp7)
1782 ; CHECK: }
1783
1784 %0 = type { i8* (i8*, %struct._message_ref_t*, ...)*, i8* }
1785 %1 = type opaque
1786 %2 = type opaque
1787 %3 = type opaque
1788 %4 = type opaque
1789 %5 = type opaque
1790 %struct.NSConstantString = type { i32*, i32, i8*, i64 }
1791 %struct._NSRange = type { i64, i64 }
1792 %struct.__CFString = type opaque
1793 %struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
1794 %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* }
1795 %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
1796 %struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
1797 %struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
1798 %struct._message_ref_t = type { i8*, i8* }
1799 %struct._objc_cache = type opaque
1800 %struct._objc_method = type { i8*, i8*, i8* }
1801 %struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
1802 %struct._prop_list_t = type { i32, i32, [0 x %struct._message_ref_t] }
1803 %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 }
1804
1805 @"\01L_OBJC_CLASSLIST_REFERENCES_$_17" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
1806 @kUTTypePlainText = external constant %struct.__CFString*
1807 @"\01L_OBJC_SELECTOR_REFERENCES_19" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1808 @"\01L_OBJC_SELECTOR_REFERENCES_21" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1809 @"\01L_OBJC_SELECTOR_REFERENCES_23" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1810 @"\01L_OBJC_SELECTOR_REFERENCES_25" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1811 @"\01L_OBJC_CLASSLIST_REFERENCES_$_26" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
1812 @"\01L_OBJC_SELECTOR_REFERENCES_28" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1813 @"\01L_OBJC_CLASSLIST_REFERENCES_$_29" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
1814 @"\01L_OBJC_SELECTOR_REFERENCES_31" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1815 @"\01L_OBJC_SELECTOR_REFERENCES_33" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1816 @"\01L_OBJC_SELECTOR_REFERENCES_35" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1817 @"\01L_OBJC_SELECTOR_REFERENCES_37" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1818 @"\01L_OBJC_CLASSLIST_REFERENCES_$_38" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
1819 @"\01L_OBJC_SELECTOR_REFERENCES_40" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1820 @"\01L_OBJC_SELECTOR_REFERENCES_42" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1821 @_unnamed_cfstring_44 = external hidden constant %struct.NSConstantString, section "__DATA,__cfstring"
1822 @"\01L_OBJC_SELECTOR_REFERENCES_46" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1823 @"\01L_OBJC_SELECTOR_REFERENCES_48" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1824 @"\01l_objc_msgSend_fixup_isEqual_" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16
1825 @"\01L_OBJC_CLASSLIST_REFERENCES_$_50" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
1826 @NSCocoaErrorDomain = external constant %1*
1827 @"\01L_OBJC_CLASSLIST_REFERENCES_$_51" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
1828 @NSFilePathErrorKey = external constant %1*
1829 @"\01L_OBJC_SELECTOR_REFERENCES_53" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1830 @"\01L_OBJC_SELECTOR_REFERENCES_55" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1831 @"\01L_OBJC_CLASSLIST_REFERENCES_$_56" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
1832 @"\01L_OBJC_SELECTOR_REFERENCES_58" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1833 @"\01L_OBJC_SELECTOR_REFERENCES_60" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
1834
1835 declare %1* @truncatedString(%1*, i64)
1836 define void @TextEditTest(%2* %self, %3* %pboard) {
1837 entry:
1838   %err = alloca %4*, align 8
1839   %tmp7 = bitcast %2* %self to i8*
1840   %tmp8 = call i8* @objc_retain(i8* %tmp7) nounwind
1841   store %4* null, %4** %err, align 8
1842   %tmp1 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_17", align 8
1843   %tmp2 = load %struct.__CFString** @kUTTypePlainText, align 8
1844   %tmp3 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_19", align 8
1845   %tmp4 = bitcast %struct._class_t* %tmp1 to i8*
1846   %call5 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp4, i8* %tmp3, %struct.__CFString* %tmp2)
1847   %tmp5 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_21", align 8
1848   %tmp6 = bitcast %3* %pboard to i8*
1849   %call76 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp5, i8* %call5)
1850   %tmp9 = call i8* @objc_retain(i8* %call76) nounwind
1851   %tobool = icmp eq i8* %tmp9, null
1852   br i1 %tobool, label %end, label %land.lhs.true
1853
1854 land.lhs.true:                                    ; preds = %entry
1855   %tmp11 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_23", align 8
1856   %call137 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp11, i8* %tmp9)
1857   %tmp = bitcast i8* %call137 to %1*
1858   %tmp10 = call i8* @objc_retain(i8* %call137) nounwind
1859   call void @objc_release(i8* null) nounwind
1860   %tmp12 = call i8* @objc_retain(i8* %call137) nounwind
1861   call void @objc_release(i8* null) nounwind
1862   %tobool16 = icmp eq i8* %call137, null
1863   br i1 %tobool16, label %end, label %if.then
1864
1865 if.then:                                          ; preds = %land.lhs.true
1866   %tmp19 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
1867   %call21 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %call137, i8* %tmp19)
1868   %tobool22 = icmp eq i8 %call21, 0
1869   br i1 %tobool22, label %if.then44, label %land.lhs.true23
1870
1871 land.lhs.true23:                                  ; preds = %if.then
1872   %tmp24 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
1873   %tmp26 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
1874   %tmp27 = bitcast %struct._class_t* %tmp24 to i8*
1875   %call2822 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp27, i8* %tmp26, i8* %call137)
1876   %tmp13 = bitcast i8* %call2822 to %5*
1877   %tmp14 = call i8* @objc_retain(i8* %call2822) nounwind
1878   call void @objc_release(i8* null) nounwind
1879   %tobool30 = icmp eq i8* %call2822, null
1880   br i1 %tobool30, label %if.then44, label %if.end
1881
1882 if.end:                                           ; preds = %land.lhs.true23
1883   %tmp32 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
1884   %tmp33 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
1885   %tmp34 = bitcast %struct._class_t* %tmp32 to i8*
1886   %call35 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp34, i8* %tmp33)
1887   %tmp37 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
1888   %call3923 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call35, i8* %tmp37, i8* %call2822, i32 signext 1, %4** %err)
1889   %cmp = icmp eq i8* %call3923, null
1890   br i1 %cmp, label %if.then44, label %end
1891
1892 if.then44:                                        ; preds = %if.end, %land.lhs.true23, %if.then
1893   %url.025 = phi %5* [ %tmp13, %if.end ], [ %tmp13, %land.lhs.true23 ], [ null, %if.then ]
1894   %tmp49 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_35", align 8
1895   %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)
1896   %call513 = extractvalue %struct._NSRange %call51, 0
1897   %call514 = extractvalue %struct._NSRange %call51, 1
1898   %tmp52 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_37", align 8
1899   %call548 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call137, i8* %tmp52, i64 %call513, i64 %call514)
1900   %tmp55 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_38", align 8
1901   %tmp56 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_40", align 8
1902   %tmp57 = bitcast %struct._class_t* %tmp55 to i8*
1903   %call58 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp57, i8* %tmp56)
1904   %tmp59 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_42", align 8
1905   %call6110 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call548, i8* %tmp59, i8* %call58)
1906   %tmp15 = call i8* @objc_retain(i8* %call6110) nounwind
1907   call void @objc_release(i8* %call137) nounwind
1908   %tmp64 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_46", align 8
1909   %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*))
1910   %tobool67 = icmp eq i8 %call66, 0
1911   br i1 %tobool67, label %if.end74, label %if.then68
1912
1913 if.then68:                                        ; preds = %if.then44
1914   %tmp70 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_48", align 8
1915   %call7220 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call6110, i8* %tmp70)
1916   %tmp16 = call i8* @objc_retain(i8* %call7220) nounwind
1917   call void @objc_release(i8* %call6110) nounwind
1918   br label %if.end74
1919
1920 if.end74:                                         ; preds = %if.then68, %if.then44
1921   %filename.0.in = phi i8* [ %call7220, %if.then68 ], [ %call6110, %if.then44 ]
1922   %filename.0 = bitcast i8* %filename.0.in to %1*
1923   %tmp17 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to i8**), align 16
1924   %tmp18 = bitcast i8* %tmp17 to i8 (i8*, %struct._message_ref_t*, i8*, ...)*
1925   %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)
1926   %tobool79 = icmp eq i8 %call78, 0
1927   br i1 %tobool79, label %land.lhs.true80, label %if.then109
1928
1929 land.lhs.true80:                                  ; preds = %if.end74
1930   %tmp82 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
1931   %call84 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %filename.0.in, i8* %tmp82)
1932   %tobool86 = icmp eq i8 %call84, 0
1933   br i1 %tobool86, label %if.then109, label %if.end106
1934
1935 if.end106:                                        ; preds = %land.lhs.true80
1936   %tmp88 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
1937   %tmp90 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
1938   %tmp91 = bitcast %struct._class_t* %tmp88 to i8*
1939   %call9218 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp91, i8* %tmp90, i8* %filename.0.in)
1940   %tmp20 = bitcast i8* %call9218 to %5*
1941   %tmp21 = call i8* @objc_retain(i8* %call9218) nounwind
1942   %tmp22 = bitcast %5* %url.025 to i8*
1943   call void @objc_release(i8* %tmp22) nounwind
1944   %tmp94 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
1945   %tmp95 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
1946   %tmp96 = bitcast %struct._class_t* %tmp94 to i8*
1947   %call97 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp96, i8* %tmp95)
1948   %tmp99 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
1949   %call10119 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call97, i8* %tmp99, i8* %call9218, i32 signext 1, %4** %err)
1950   %phitmp = icmp eq i8* %call10119, null
1951   br i1 %phitmp, label %if.then109, label %end
1952
1953 if.then109:                                       ; preds = %if.end106, %land.lhs.true80, %if.end74
1954   %url.129 = phi %5* [ %tmp20, %if.end106 ], [ %url.025, %if.end74 ], [ %url.025, %land.lhs.true80 ]
1955   %tmp110 = load %4** %err, align 8
1956   %tobool111 = icmp eq %4* %tmp110, null
1957   br i1 %tobool111, label %if.then112, label %if.end125
1958
1959 if.then112:                                       ; preds = %if.then109
1960   %tmp113 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_50", align 8
1961   %tmp114 = load %1** @NSCocoaErrorDomain, align 8
1962   %tmp115 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_51", align 8
1963   %call117 = call %1* @truncatedString(%1* %filename.0, i64 1034)
1964   %tmp118 = load %1** @NSFilePathErrorKey, align 8
1965   %tmp119 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_53", align 8
1966   %tmp120 = bitcast %struct._class_t* %tmp115 to i8*
1967   %call12113 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp120, i8* %tmp119, %1* %call117, %1* %tmp118, i8* null)
1968   %tmp122 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_55", align 8
1969   %tmp123 = bitcast %struct._class_t* %tmp113 to i8*
1970   %call12414 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp123, i8* %tmp122, %1* %tmp114, i64 258, i8* %call12113)
1971   %tmp23 = call i8* @objc_retain(i8* %call12414) nounwind
1972   %tmp25 = call i8* @objc_autorelease(i8* %tmp23) nounwind
1973   %tmp28 = bitcast i8* %tmp25 to %4*
1974   store %4* %tmp28, %4** %err, align 8
1975   br label %if.end125
1976
1977 if.end125:                                        ; preds = %if.then112, %if.then109
1978   %tmp127 = phi %4* [ %tmp110, %if.then109 ], [ %tmp28, %if.then112 ]
1979   %tmp126 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_56", align 8
1980   %tmp128 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_58", align 8
1981   %tmp129 = bitcast %struct._class_t* %tmp126 to i8*
1982   %call13015 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp129, i8* %tmp128, %4* %tmp127)
1983   %tmp131 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_60", align 8
1984   %call13317 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call13015, i8* %tmp131)
1985   br label %end
1986
1987 end:                                              ; preds = %if.end125, %if.end106, %if.end, %land.lhs.true, %entry
1988   %filename.2 = phi %1* [ %filename.0, %if.end106 ], [ %filename.0, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
1989   %origFilename.0 = phi %1* [ %tmp, %if.end106 ], [ %tmp, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
1990   %url.2 = phi %5* [ %tmp20, %if.end106 ], [ %url.129, %if.end125 ], [ null, %land.lhs.true ], [ null, %entry ], [ %tmp13, %if.end ]
1991   call void @objc_release(i8* %tmp9) nounwind, !clang.imprecise_release !0
1992   %tmp29 = bitcast %5* %url.2 to i8*
1993   call void @objc_release(i8* %tmp29) nounwind, !clang.imprecise_release !0
1994   %tmp30 = bitcast %1* %origFilename.0 to i8*
1995   call void @objc_release(i8* %tmp30) nounwind, !clang.imprecise_release !0
1996   %tmp31 = bitcast %1* %filename.2 to i8*
1997   call void @objc_release(i8* %tmp31) nounwind, !clang.imprecise_release !0
1998   call void @objc_release(i8* %tmp7) nounwind, !clang.imprecise_release !0
1999   ret void
2000 }
2001
2002 !0 = metadata !{}
2003
2004 declare i32 @__gxx_personality_v0(...)