test/Transforms/ObjCARC/basic.ll

   1 ; RUN: opt -basicaa -objc-arc -S < %s | FileCheck %s
   2
   3 target datalayout = "e-p:64:64:64"
   4
   5 declare i8* @objc_retain(i8*)
   6 declare i8* @objc_retainAutoreleasedReturnValue(i8*)
   7 declare void @objc_release(i8*)
   8 declare i8* @objc_autorelease(i8*)
   9 declare i8* @objc_autoreleaseReturnValue(i8*)
  10 declare void @objc_autoreleasePoolPop(i8*)
  11 declare i8* @objc_autoreleasePoolPush()
  12 declare i8* @objc_retainBlock(i8*)
  13
  14 declare i8* @objc_retainedObject(i8*)
  15 declare i8* @objc_unretainedObject(i8*)
  16 declare i8* @objc_unretainedPointer(i8*)
  17
  18 declare void @use_pointer(i8*)
  19 declare void @callee()
  20 declare void @callee_fnptr(void ()*)
  21 declare void @invokee()
  22 declare i8* @returner()
  23 declare void @bar(i32 ()*)
  24
  25 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
  26
  27 declare i8* @objc_msgSend(i8*, i8*, ...)
  28
  29 ; Simple retain+release pair deletion, with some intervening control
  30 ; flow and harmless instructions.
  31
  32 ; CHECK: define void @test0_precise(i32* %x, i1 %p) [[NUW:#[0-9]+]] {
  33 ; CHECK: @objc_retain
  34 ; CHECK: @objc_release
  35 ; CHECK: }
  36 define void @test0_precise(i32* %x, i1 %p) nounwind {
  37 entry:
  38   %a = bitcast i32* %x to i8*
  39   %0 = call i8* @objc_retain(i8* %a) nounwind
  40   br i1 %p, label %t, label %f
  41
  42 t:
  43   store i8 3, i8* %a
  44   %b = bitcast i32* %x to float*
  45   store float 2.0, float* %b
  46   br label %return
  47
  48 f:
  49   store i32 7, i32* %x
  50   br label %return
  51
  52 return:
  53   %c = bitcast i32* %x to i8*
  54   call void @objc_release(i8* %c) nounwind
  55   ret void
  56 }
  57
  58 ; CHECK: define void @test0_imprecise(i32* %x, i1 %p) [[NUW]] {
  59 ; CHECK-NOT: @objc_
  60 ; CHECK: }
  61 define void @test0_imprecise(i32* %x, i1 %p) nounwind {
  62 entry:
  63   %a = bitcast i32* %x to i8*
  64   %0 = call i8* @objc_retain(i8* %a) nounwind
  65   br i1 %p, label %t, label %f
  66
  67 t:
  68   store i8 3, i8* %a
  69   %b = bitcast i32* %x to float*
  70   store float 2.0, float* %b
  71   br label %return
  72
  73 f:
  74   store i32 7, i32* %x
  75   br label %return
  76
  77 return:
  78   %c = bitcast i32* %x to i8*
  79   call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
  80   ret void
  81 }
  82
  83 ; Like test0 but the release isn't always executed when the retain is,
  84 ; so the optimization is not safe.
  85
  86 ; TODO: Make the objc_release's argument be %0.
  87
  88 ; CHECK: define void @test1_precise(i32* %x, i1 %p, i1 %q) [[NUW]] {
  89 ; CHECK: @objc_retain(i8* %a)
  90 ; CHECK: @objc_release
  91 ; CHECK: }
  92 define void @test1_precise(i32* %x, i1 %p, i1 %q) nounwind {
  93 entry:
  94   %a = bitcast i32* %x to i8*
  95   %0 = call i8* @objc_retain(i8* %a) nounwind
  96   br i1 %p, label %t, label %f
  97
  98 t:
  99   store i8 3, i8* %a
 100   %b = bitcast i32* %x to float*
 101   store float 2.0, float* %b
 102   br label %return
 103
 104 f:
 105   store i32 7, i32* %x
 106   call void @callee()
 107   br i1 %q, label %return, label %alt_return
 108
 109 return:
 110   %c = bitcast i32* %x to i8*
 111   call void @objc_release(i8* %c) nounwind
 112   ret void
 113
 114 alt_return:
 115   ret void
 116 }
 117
 118 ; CHECK: define void @test1_imprecise(i32* %x, i1 %p, i1 %q) [[NUW]] {
 119 ; CHECK: @objc_retain(i8* %a)
 120 ; CHECK: @objc_release
 121 ; CHECK: }
 122 define void @test1_imprecise(i32* %x, i1 %p, i1 %q) nounwind {
 123 entry:
 124   %a = bitcast i32* %x to i8*
 125   %0 = call i8* @objc_retain(i8* %a) nounwind
 126   br i1 %p, label %t, label %f
 127
 128 t:
 129   store i8 3, i8* %a
 130   %b = bitcast i32* %x to float*
 131   store float 2.0, float* %b
 132   br label %return
 133
 134 f:
 135   store i32 7, i32* %x
 136   call void @callee()
 137   br i1 %q, label %return, label %alt_return
 138
 139 return:
 140   %c = bitcast i32* %x to i8*
 141   call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
 142   ret void
 143
 144 alt_return:
 145   ret void
 146 }
 147
 148
 149 ; Don't do partial elimination into two different CFG diamonds.
 150
 151 ; CHECK: define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
 152 ; CHECK: entry:
 153 ; CHECK:   tail call i8* @objc_retain(i8* %x) [[NUW]]
 154 ; CHECK-NOT: @objc_
 155 ; CHECK: if.end5:
 156 ; CHECK:   tail call void @objc_release(i8* %x) [[NUW]]
 157 ; CHECK-NOT: @objc_
 158 ; CHECK: }
 159 define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
 160 entry:
 161   tail call i8* @objc_retain(i8* %x) nounwind
 162   br i1 %p, label %if.then, label %if.end
 163
 164 if.then:                                          ; preds = %entry
 165   tail call void @callee()
 166   br label %if.end
 167
 168 if.end:                                           ; preds = %if.then, %entry
 169   br i1 %q, label %if.then3, label %if.end5
 170
 171 if.then3:                                         ; preds = %if.end
 172   tail call void @use_pointer(i8* %x)
 173   br label %if.end5
 174
 175 if.end5:                                          ; preds = %if.then3, %if.end
 176   tail call void @objc_release(i8* %x) nounwind
 177   ret void
 178 }
 179
 180 ; CHECK-LABEL: define void @test1b_imprecise(
 181 ; CHECK: entry:
 182 ; CHECK:   tail call i8* @objc_retain(i8* %x) [[NUW:#[0-9]+]]
 183 ; CHECK-NOT: @objc_
 184 ; CHECK: if.end5:
 185 ; CHECK:   tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE:[0-9]+]]
 186 ; CHECK-NOT: @objc_
 187 ; CHECK: }
 188 define void @test1b_imprecise(i8* %x, i1 %p, i1 %q) {
 189 entry:
 190   tail call i8* @objc_retain(i8* %x) nounwind
 191   br i1 %p, label %if.then, label %if.end
 192
 193 if.then:                                          ; preds = %entry
 194   tail call void @callee()
 195   br label %if.end
 196
 197 if.end:                                           ; preds = %if.then, %entry
 198   br i1 %q, label %if.then3, label %if.end5
 199
 200 if.then3:                                         ; preds = %if.end
 201   tail call void @use_pointer(i8* %x)
 202   br label %if.end5
 203
 204 if.end5:                                          ; preds = %if.then3, %if.end
 205   tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
 206   ret void
 207 }
 208
 209
 210 ; Like test0 but the pointer is passed to an intervening call,
 211 ; so the optimization is not safe.
 212
 213 ; CHECK-LABEL: define void @test2_precise(
 214 ; CHECK: @objc_retain(i8* %a)
 215 ; CHECK: @objc_release
 216 ; CHECK: }
 217 define void @test2_precise(i32* %x, i1 %p) nounwind {
 218 entry:
 219   %a = bitcast i32* %x to i8*
 220   %0 = call i8* @objc_retain(i8* %a) nounwind
 221   br i1 %p, label %t, label %f
 222
 223 t:
 224   store i8 3, i8* %a
 225   %b = bitcast i32* %x to float*
 226   store float 2.0, float* %b
 227   br label %return
 228
 229 f:
 230   store i32 7, i32* %x
 231   call void @use_pointer(i8* %0)
 232   %d = bitcast i32* %x to float*
 233   store float 3.0, float* %d
 234   br label %return
 235
 236 return:
 237   %c = bitcast i32* %x to i8*
 238   call void @objc_release(i8* %c) nounwind
 239   ret void
 240 }
 241
 242 ; CHECK-LABEL: define void @test2_imprecise(
 243 ; CHECK: @objc_retain(i8* %a)
 244 ; CHECK: @objc_release
 245 ; CHECK: }
 246 define void @test2_imprecise(i32* %x, i1 %p) nounwind {
 247 entry:
 248   %a = bitcast i32* %x to i8*
 249   %0 = call i8* @objc_retain(i8* %a) nounwind
 250   br i1 %p, label %t, label %f
 251
 252 t:
 253   store i8 3, i8* %a
 254   %b = bitcast i32* %x to float*
 255   store float 2.0, float* %b
 256   br label %return
 257
 258 f:
 259   store i32 7, i32* %x
 260   call void @use_pointer(i8* %0)
 261   %d = bitcast i32* %x to float*
 262   store float 3.0, float* %d
 263   br label %return
 264
 265 return:
 266   %c = bitcast i32* %x to i8*
 267   call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
 268   ret void
 269 }
 270
 271 ; Like test0 but the release is in a loop,
 272 ; so the optimization is not safe.
 273
 274 ; TODO: For now, assume this can't happen.
 275
 276 ; CHECK-LABEL: define void @test3_precise(
 277 ; TODO: @objc_retain(i8* %a)
 278 ; TODO: @objc_release
 279 ; CHECK: }
 280 define void @test3_precise(i32* %x, i1* %q) nounwind {
 281 entry:
 282   %a = bitcast i32* %x to i8*
 283   %0 = call i8* @objc_retain(i8* %a) nounwind
 284   br label %loop
 285
 286 loop:
 287   %c = bitcast i32* %x to i8*
 288   call void @objc_release(i8* %c) nounwind
 289   %j = load volatile i1, i1* %q
 290   br i1 %j, label %loop, label %return
 291
 292 return:
 293   ret void
 294 }
 295
 296 ; CHECK-LABEL: define void @test3_imprecise(
 297 ; TODO: @objc_retain(i8* %a)
 298 ; TODO: @objc_release
 299 ; CHECK: }
 300 define void @test3_imprecise(i32* %x, i1* %q) nounwind {
 301 entry:
 302   %a = bitcast i32* %x to i8*
 303   %0 = call i8* @objc_retain(i8* %a) nounwind
 304   br label %loop
 305
 306 loop:
 307   %c = bitcast i32* %x to i8*
 308   call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
 309   %j = load volatile i1, i1* %q
 310   br i1 %j, label %loop, label %return
 311
 312 return:
 313   ret void
 314 }
 315
 316
 317 ; TODO: For now, assume this can't happen.
 318
 319 ; Like test0 but the retain is in a loop,
 320 ; so the optimization is not safe.
 321
 322 ; CHECK-LABEL: define void @test4_precise(
 323 ; TODO: @objc_retain(i8* %a)
 324 ; TODO: @objc_release
 325 ; CHECK: }
 326 define void @test4_precise(i32* %x, i1* %q) nounwind {
 327 entry:
 328   br label %loop
 329
 330 loop:
 331   %a = bitcast i32* %x to i8*
 332   %0 = call i8* @objc_retain(i8* %a) nounwind
 333   %j = load volatile i1, i1* %q
 334   br i1 %j, label %loop, label %return
 335
 336 return:
 337   %c = bitcast i32* %x to i8*
 338   call void @objc_release(i8* %c) nounwind
 339   ret void
 340 }
 341
 342 ; CHECK-LABEL: define void @test4_imprecise(
 343 ; TODO: @objc_retain(i8* %a)
 344 ; TODO: @objc_release
 345 ; CHECK: }
 346 define void @test4_imprecise(i32* %x, i1* %q) nounwind {
 347 entry:
 348   br label %loop
 349
 350 loop:
 351   %a = bitcast i32* %x to i8*
 352   %0 = call i8* @objc_retain(i8* %a) nounwind
 353   %j = load volatile i1, i1* %q
 354   br i1 %j, label %loop, label %return
 355
 356 return:
 357   %c = bitcast i32* %x to i8*
 358   call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
 359   ret void
 360 }
 361
 362
 363 ; Like test0 but the pointer is conditionally passed to an intervening call,
 364 ; so the optimization is not safe.
 365
 366 ; CHECK-LABEL: define void @test5a(
 367 ; CHECK: @objc_retain(i8*
 368 ; CHECK: @objc_release
 369 ; CHECK: }
 370 define void @test5a(i32* %x, i1 %q, i8* %y) nounwind {
 371 entry:
 372   %a = bitcast i32* %x to i8*
 373   %0 = call i8* @objc_retain(i8* %a) nounwind
 374   %s = select i1 %q, i8* %y, i8* %0
 375   call void @use_pointer(i8* %s)
 376   store i32 7, i32* %x
 377   %c = bitcast i32* %x to i8*
 378   call void @objc_release(i8* %c) nounwind
 379   ret void
 380 }
 381
 382 ; CHECK-LABEL: define void @test5b(
 383 ; CHECK: @objc_retain(i8*
 384 ; CHECK: @objc_release
 385 ; CHECK: }
 386 define void @test5b(i32* %x, i1 %q, i8* %y) nounwind {
 387 entry:
 388   %a = bitcast i32* %x to i8*
 389   %0 = call i8* @objc_retain(i8* %a) nounwind
 390   %s = select i1 %q, i8* %y, i8* %0
 391   call void @use_pointer(i8* %s)
 392   store i32 7, i32* %x
 393   %c = bitcast i32* %x to i8*
 394   call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
 395   ret void
 396 }
 397
 398
 399 ; retain+release pair deletion, where the release happens on two different
 400 ; flow paths.
 401
 402 ; CHECK-LABEL: define void @test6a(
 403 ; CHECK: entry:
 404 ; CHECK:   tail call i8* @objc_retain(
 405 ; CHECK: t:
 406 ; CHECK:   call void @objc_release(
 407 ; CHECK: f:
 408 ; CHECK:   call void @objc_release(
 409 ; CHECK: return:
 410 ; CHECK: }
 411 define void @test6a(i32* %x, i1 %p) nounwind {
 412 entry:
 413   %a = bitcast i32* %x to i8*
 414   %0 = call i8* @objc_retain(i8* %a) nounwind
 415   br i1 %p, label %t, label %f
 416
 417 t:
 418   store i8 3, i8* %a
 419   %b = bitcast i32* %x to float*
 420   store float 2.0, float* %b
 421   %ct = bitcast i32* %x to i8*
 422   call void @objc_release(i8* %ct) nounwind
 423   br label %return
 424
 425 f:
 426   store i32 7, i32* %x
 427   call void @callee()
 428   %cf = bitcast i32* %x to i8*
 429   call void @objc_release(i8* %cf) nounwind
 430   br label %return
 431
 432 return:
 433   ret void
 434 }
 435
 436 ; CHECK-LABEL: define void @test6b(
 437 ; CHECK-NOT: @objc_
 438 ; CHECK: }
 439 define void @test6b(i32* %x, i1 %p) nounwind {
 440 entry:
 441   %a = bitcast i32* %x to i8*
 442   %0 = call i8* @objc_retain(i8* %a) nounwind
 443   br i1 %p, label %t, label %f
 444
 445 t:
 446   store i8 3, i8* %a
 447   %b = bitcast i32* %x to float*
 448   store float 2.0, float* %b
 449   %ct = bitcast i32* %x to i8*
 450   call void @objc_release(i8* %ct) nounwind, !clang.imprecise_release !0
 451   br label %return
 452
 453 f:
 454   store i32 7, i32* %x
 455   call void @callee()
 456   %cf = bitcast i32* %x to i8*
 457   call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
 458   br label %return
 459
 460 return:
 461   ret void
 462 }
 463
 464 ; CHECK-LABEL: define void @test6c(
 465 ; CHECK: entry:
 466 ; CHECK:   tail call i8* @objc_retain(
 467 ; CHECK: t:
 468 ; CHECK:   call void @objc_release(
 469 ; CHECK: f:
 470 ; CHECK:   call void @objc_release(
 471 ; CHECK: return:
 472 ; CHECK: }
 473 define void @test6c(i32* %x, i1 %p) nounwind {
 474 entry:
 475   %a = bitcast i32* %x to i8*
 476   %0 = call i8* @objc_retain(i8* %a) nounwind
 477   br i1 %p, label %t, label %f
 478
 479 t:
 480   store i8 3, i8* %a
 481   %b = bitcast i32* %x to float*
 482   store float 2.0, float* %b
 483   %ct = bitcast i32* %x to i8*
 484   call void @objc_release(i8* %ct) nounwind
 485   br label %return
 486
 487 f:
 488   store i32 7, i32* %x
 489   call void @callee()
 490   %cf = bitcast i32* %x to i8*
 491   call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
 492   br label %return
 493
 494 return:
 495   ret void
 496 }
 497
 498 ; CHECK-LABEL: define void @test6d(
 499 ; CHECK: entry:
 500 ; CHECK:   tail call i8* @objc_retain(
 501 ; CHECK: t:
 502 ; CHECK:   call void @objc_release(
 503 ; CHECK: f:
 504 ; CHECK:   call void @objc_release(
 505 ; CHECK: return:
 506 ; CHECK: }
 507 define void @test6d(i32* %x, i1 %p) nounwind {
 508 entry:
 509   %a = bitcast i32* %x to i8*
 510   %0 = call i8* @objc_retain(i8* %a) nounwind
 511   br i1 %p, label %t, label %f
 512
 513 t:
 514   store i8 3, i8* %a
 515   %b = bitcast i32* %x to float*
 516   store float 2.0, float* %b
 517   %ct = bitcast i32* %x to i8*
 518   call void @objc_release(i8* %ct) nounwind, !clang.imprecise_release !0
 519   br label %return
 520
 521 f:
 522   store i32 7, i32* %x
 523   call void @callee()
 524   %cf = bitcast i32* %x to i8*
 525   call void @objc_release(i8* %cf) nounwind
 526   br label %return
 527
 528 return:
 529   ret void
 530 }
 531
 532
 533 ; retain+release pair deletion, where the retain happens on two different
 534 ; flow paths.
 535
 536 ; CHECK-LABEL:     define void @test7(
 537 ; CHECK:     entry:
 538 ; CHECK-NOT:   objc_
 539 ; CHECK:     t:
 540 ; CHECK:       call i8* @objc_retain
 541 ; CHECK:     f:
 542 ; CHECK:       call i8* @objc_retain
 543 ; CHECK:     return:
 544 ; CHECK:       call void @objc_release
 545 ; CHECK: }
 546 define void @test7(i32* %x, i1 %p) nounwind {
 547 entry:
 548   %a = bitcast i32* %x to i8*
 549   br i1 %p, label %t, label %f
 550
 551 t:
 552   %0 = call i8* @objc_retain(i8* %a) nounwind
 553   store i8 3, i8* %a
 554   %b = bitcast i32* %x to float*
 555   store float 2.0, float* %b
 556   br label %return
 557
 558 f:
 559   %1 = call i8* @objc_retain(i8* %a) nounwind
 560   store i32 7, i32* %x
 561   call void @callee()
 562   br label %return
 563
 564 return:
 565   %c = bitcast i32* %x to i8*
 566   call void @objc_release(i8* %c) nounwind
 567   ret void
 568 }
 569
 570 ; CHECK-LABEL: define void @test7b(
 571 ; CHECK-NOT: @objc_
 572 ; CHECK: }
 573 define void @test7b(i32* %x, i1 %p) nounwind {
 574 entry:
 575   %a = bitcast i32* %x to i8*
 576   br i1 %p, label %t, label %f
 577
 578 t:
 579   %0 = call i8* @objc_retain(i8* %a) nounwind
 580   store i8 3, i8* %a
 581   %b = bitcast i32* %x to float*
 582   store float 2.0, float* %b
 583   br label %return
 584
 585 f:
 586   %1 = call i8* @objc_retain(i8* %a) nounwind
 587   store i32 7, i32* %x
 588   call void @callee()
 589   br label %return
 590
 591 return:
 592   %c = bitcast i32* %x to i8*
 593   call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
 594   ret void
 595 }
 596
 597 ; Like test7, but there's a retain/retainBlock mismatch. Don't delete!
 598
 599 ; CHECK-LABEL: define void @test7c(
 600 ; CHECK: t:
 601 ; CHECK:   call i8* @objc_retainBlock
 602 ; CHECK: f:
 603 ; CHECK:   call i8* @objc_retain
 604 ; CHECK: return:
 605 ; CHECK:   call void @objc_release
 606 ; CHECK: }
 607 define void @test7c(i32* %x, i1 %p) nounwind {
 608 entry:
 609   %a = bitcast i32* %x to i8*
 610   br i1 %p, label %t, label %f
 611
 612 t:
 613   %0 = call i8* @objc_retainBlock(i8* %a) nounwind
 614   store i8 3, i8* %a
 615   %b = bitcast i32* %x to float*
 616   store float 2.0, float* %b
 617   br label %return
 618
 619 f:
 620   %1 = call i8* @objc_retain(i8* %a) nounwind
 621   store i32 7, i32* %x
 622   call void @callee()
 623   br label %return
 624
 625 return:
 626   %c = bitcast i32* %x to i8*
 627   call void @objc_release(i8* %c) nounwind
 628   ret void
 629 }
 630
 631 ; retain+release pair deletion, where the retain and release both happen on
 632 ; different flow paths. Wild!
 633
 634 ; CHECK-LABEL: define void @test8a(
 635 ; CHECK: entry:
 636 ; CHECK: t:
 637 ; CHECK:   @objc_retain
 638 ; CHECK: f:
 639 ; CHECK:   @objc_retain
 640 ; CHECK: mid:
 641 ; CHECK: u:
 642 ; CHECK:   @objc_release
 643 ; CHECK: g:
 644 ; CHECK:   @objc_release
 645 ; CHECK: return:
 646 ; CHECK: }
 647 define void @test8a(i32* %x, i1 %p, i1 %q) nounwind {
 648 entry:
 649   %a = bitcast i32* %x to i8*
 650   br i1 %p, label %t, label %f
 651
 652 t:
 653   %0 = call i8* @objc_retain(i8* %a) nounwind
 654   store i8 3, i8* %a
 655   %b = bitcast i32* %x to float*
 656   store float 2.0, float* %b
 657   br label %mid
 658
 659 f:
 660   %1 = call i8* @objc_retain(i8* %a) nounwind
 661   store i32 7, i32* %x
 662   br label %mid
 663
 664 mid:
 665   br i1 %q, label %u, label %g
 666
 667 u:
 668   call void @callee()
 669   %cu = bitcast i32* %x to i8*
 670   call void @objc_release(i8* %cu) nounwind
 671   br label %return
 672
 673 g:
 674   %cg = bitcast i32* %x to i8*
 675   call void @objc_release(i8* %cg) nounwind
 676   br label %return
 677
 678 return:
 679   ret void
 680 }
 681
 682 ; CHECK-LABEL: define void @test8b(
 683 ; CHECK-NOT: @objc_
 684 ; CHECK: }
 685 define void @test8b(i32* %x, i1 %p, i1 %q) nounwind {
 686 entry:
 687   %a = bitcast i32* %x to i8*
 688   br i1 %p, label %t, label %f
 689
 690 t:
 691   %0 = call i8* @objc_retain(i8* %a) nounwind
 692   store i8 3, i8* %a
 693   %b = bitcast i32* %x to float*
 694   store float 2.0, float* %b
 695   br label %mid
 696
 697 f:
 698   %1 = call i8* @objc_retain(i8* %a) nounwind
 699   store i32 7, i32* %x
 700   br label %mid
 701
 702 mid:
 703   br i1 %q, label %u, label %g
 704
 705 u:
 706   call void @callee()
 707   %cu = bitcast i32* %x to i8*
 708   call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
 709   br label %return
 710
 711 g:
 712   %cg = bitcast i32* %x to i8*
 713   call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
 714   br label %return
 715
 716 return:
 717   ret void
 718 }
 719
 720 ; CHECK-LABEL: define void @test8c(
 721 ; CHECK: entry:
 722 ; CHECK: t:
 723 ; CHECK:   @objc_retain
 724 ; CHECK: f:
 725 ; CHECK:   @objc_retain
 726 ; CHECK: mid:
 727 ; CHECK: u:
 728 ; CHECK:   @objc_release
 729 ; CHECK: g:
 730 ; CHECK:   @objc_release
 731 ; CHECK: return:
 732 ; CHECK: }
 733 define void @test8c(i32* %x, i1 %p, i1 %q) nounwind {
 734 entry:
 735   %a = bitcast i32* %x to i8*
 736   br i1 %p, label %t, label %f
 737
 738 t:
 739   %0 = call i8* @objc_retain(i8* %a) nounwind
 740   store i8 3, i8* %a
 741   %b = bitcast i32* %x to float*
 742   store float 2.0, float* %b
 743   br label %mid
 744
 745 f:
 746   %1 = call i8* @objc_retain(i8* %a) nounwind
 747   store i32 7, i32* %x
 748   br label %mid
 749
 750 mid:
 751   br i1 %q, label %u, label %g
 752
 753 u:
 754   call void @callee()
 755   %cu = bitcast i32* %x to i8*
 756   call void @objc_release(i8* %cu) nounwind
 757   br label %return
 758
 759 g:
 760   %cg = bitcast i32* %x to i8*
 761   call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
 762   br label %return
 763
 764 return:
 765   ret void
 766 }
 767
 768 ; CHECK-LABEL: define void @test8d(
 769 ; CHECK: entry:
 770 ; CHECK: t:
 771 ; CHECK:   @objc_retain
 772 ; CHECK: f:
 773 ; CHECK:   @objc_retain
 774 ; CHECK: mid:
 775 ; CHECK: u:
 776 ; CHECK:   @objc_release
 777 ; CHECK: g:
 778 ; CHECK:   @objc_release
 779 ; CHECK: return:
 780 ; CHECK: }
 781 define void @test8d(i32* %x, i1 %p, i1 %q) nounwind {
 782 entry:
 783   %a = bitcast i32* %x to i8*
 784   br i1 %p, label %t, label %f
 785
 786 t:
 787   %0 = call i8* @objc_retain(i8* %a) nounwind
 788   store i8 3, i8* %a
 789   %b = bitcast i32* %x to float*
 790   store float 2.0, float* %b
 791   br label %mid
 792
 793 f:
 794   %1 = call i8* @objc_retain(i8* %a) nounwind
 795   store i32 7, i32* %x
 796   br label %mid
 797
 798 mid:
 799   br i1 %q, label %u, label %g
 800
 801 u:
 802   call void @callee()
 803   %cu = bitcast i32* %x to i8*
 804   call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
 805   br label %return
 806
 807 g:
 808   %cg = bitcast i32* %x to i8*
 809   call void @objc_release(i8* %cg) nounwind
 810   br label %return
 811
 812 return:
 813   ret void
 814 }
 815
 816 ; Trivial retain+release pair deletion.
 817
 818 ; CHECK-LABEL: define void @test9(
 819 ; CHECK-NOT: @objc_
 820 ; CHECK: }
 821 define void @test9(i8* %x) nounwind {
 822 entry:
 823   %0 = call i8* @objc_retain(i8* %x) nounwind
 824   call void @objc_release(i8* %0) nounwind
 825   ret void
 826 }
 827
 828 ; Retain+release pair, but on an unknown pointer relationship. Don't delete!
 829
 830 ; CHECK-LABEL: define void @test9b(
 831 ; CHECK: @objc_retain(i8* %x)
 832 ; CHECK: @objc_release(i8* %s)
 833 ; CHECK: }
 834 define void @test9b(i8* %x, i1 %j, i8* %p) nounwind {
 835 entry:
 836   %0 = call i8* @objc_retain(i8* %x) nounwind
 837   %s = select i1 %j, i8* %x, i8* %p
 838   call void @objc_release(i8* %s) nounwind
 839   ret void
 840 }
 841
 842 ; Trivial retain+release pair with intervening calls - don't delete!
 843
 844 ; CHECK-LABEL: define void @test10(
 845 ; CHECK: @objc_retain(i8* %x)
 846 ; CHECK: @callee
 847 ; CHECK: @use_pointer
 848 ; CHECK: @objc_release
 849 ; CHECK: }
 850 define void @test10(i8* %x) nounwind {
 851 entry:
 852   %0 = call i8* @objc_retain(i8* %x) nounwind
 853   call void @callee()
 854   call void @use_pointer(i8* %x)
 855   call void @objc_release(i8* %0) nounwind
 856   ret void
 857 }
 858
 859 ; Trivial retain+autoreleaserelease pair. Don't delete!
 860 ; Also, add a tail keyword, since objc_retain can never be passed
 861 ; a stack argument.
 862
 863 ; CHECK-LABEL: define void @test11(
 864 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
 865 ; CHECK: call i8* @objc_autorelease(i8* %0) [[NUW]]
 866 ; CHECK: }
 867 define void @test11(i8* %x) nounwind {
 868 entry:
 869   %0 = call i8* @objc_retain(i8* %x) nounwind
 870   call i8* @objc_autorelease(i8* %0) nounwind
 871   call void @use_pointer(i8* %x)
 872   ret void
 873 }
 874
 875 ; Same as test11 but with no use_pointer call. Delete the pair!
 876
 877 ; CHECK-LABEL: define void @test11a(
 878 ; CHECK: entry:
 879 ; CHECK-NEXT: ret void
 880 ; CHECK: }
 881 define void @test11a(i8* %x) nounwind {
 882 entry:
 883   %0 = call i8* @objc_retain(i8* %x) nounwind
 884   call i8* @objc_autorelease(i8* %0) nounwind
 885   ret void
 886 }
 887
 888 ; Same as test11 but the value is returned. Do not perform an RV optimization
 889 ; since if the frontend emitted code for an __autoreleasing variable, we may
 890 ; want it to be in the autorelease pool.
 891
 892 ; CHECK-LABEL: define i8* @test11b(
 893 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
 894 ; CHECK: call i8* @objc_autorelease(i8* %0) [[NUW]]
 895 ; CHECK: }
 896 define i8* @test11b(i8* %x) nounwind {
 897 entry:
 898   %0 = call i8* @objc_retain(i8* %x) nounwind
 899   call i8* @objc_autorelease(i8* %0) nounwind
 900   ret i8* %x
 901 }
 902
 903 ; We can not delete this retain, release since we do not have a post-dominating
 904 ; use of the release.
 905
 906 ; CHECK-LABEL: define void @test12(
 907 ; CHECK-NEXT: entry:
 908 ; CHECK-NEXT: @objc_retain(i8* %x)
 909 ; CHECK-NEXT: @objc_retain
 910 ; CHECK: @objc_release
 911 ; CHECK: }
 912 define void @test12(i8* %x, i64 %n) {
 913 entry:
 914   call i8* @objc_retain(i8* %x) nounwind
 915   call i8* @objc_retain(i8* %x) nounwind
 916   call void @use_pointer(i8* %x)
 917   call void @use_pointer(i8* %x)
 918   call void @objc_release(i8* %x) nounwind
 919   ret void
 920 }
 921
 922 ; Trivial retain,autorelease pair. Don't delete!
 923
 924 ; CHECK-LABEL: define void @test13(
 925 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
 926 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
 927 ; CHECK: @use_pointer(i8* %x)
 928 ; CHECK: call i8* @objc_autorelease(i8* %x) [[NUW]]
 929 ; CHECK: }
 930 define void @test13(i8* %x, i64 %n) {
 931 entry:
 932   call i8* @objc_retain(i8* %x) nounwind
 933   call i8* @objc_retain(i8* %x) nounwind
 934   call void @use_pointer(i8* %x)
 935   call i8* @objc_autorelease(i8* %x) nounwind
 936   ret void
 937 }
 938
 939 ; Delete the retain+release pair.
 940
 941 ; CHECK-LABEL: define void @test13b(
 942 ; CHECK-NEXT: entry:
 943 ; CHECK-NEXT: @objc_retain(i8* %x)
 944 ; CHECK-NEXT: @use_pointer
 945 ; CHECK-NEXT: @use_pointer
 946 ; CHECK-NEXT: @use_pointer
 947 ; CHECK-NEXT: @objc_release
 948 ; CHECK-NEXT: ret void
 949 ; CHECK-NEXT: }
 950 define void @test13b(i8* %x, i64 %n) {
 951 entry:
 952   call i8* @objc_retain(i8* %x) nounwind
 953   call i8* @objc_retain(i8* %x) nounwind
 954   call void @use_pointer(i8* %x)
 955   call void @use_pointer(i8* %x)
 956   call void @objc_release(i8* %x) nounwind
 957   call void @use_pointer(i8* %x)
 958   call void @objc_release(i8* %x) nounwind
 959   ret void
 960 }
 961
 962 ; Don't delete the retain+release pair because there's an
 963 ; autoreleasePoolPop in the way.
 964
 965 ; CHECK-LABEL: define void @test13c(
 966 ; CHECK: @objc_retain(i8* %x)
 967 ; CHECK: @objc_autoreleasePoolPop
 968 ; CHECK: @objc_retain(i8* %x)
 969 ; CHECK: @use_pointer
 970 ; CHECK: @objc_release
 971 ; CHECK: }
 972 define void @test13c(i8* %x, i64 %n) {
 973 entry:
 974   call i8* @objc_retain(i8* %x) nounwind
 975   call void @objc_autoreleasePoolPop(i8* undef)
 976   call i8* @objc_retain(i8* %x) nounwind
 977   call void @use_pointer(i8* %x)
 978   call void @use_pointer(i8* %x)
 979   call void @objc_release(i8* %x) nounwind
 980   ret void
 981 }
 982
 983 ; Like test13c, but there's an autoreleasePoolPush in the way, but that
 984 ; doesn't matter.
 985
 986 ; CHECK-LABEL: define void @test13d(
 987 ; CHECK-NEXT: entry:
 988 ; CHECK-NEXT: @objc_retain(i8* %x)
 989 ; CHECK-NEXT: @objc_autoreleasePoolPush
 990 ; CHECK-NEXT: @use_pointer
 991 ; CHECK-NEXT: @use_pointer
 992 ; CHECK-NEXT: @use_pointer
 993 ; CHECK-NEXT: @objc_release
 994 ; CHECK-NEXT: ret void
 995 ; CHECK-NEXT: }
 996 define void @test13d(i8* %x, i64 %n) {
 997 entry:
 998   call i8* @objc_retain(i8* %x) nounwind
 999   call i8* @objc_autoreleasePoolPush()
1000   call i8* @objc_retain(i8* %x) nounwind
1001   call void @use_pointer(i8* %x)
1002   call void @use_pointer(i8* %x)
1003   call void @objc_release(i8* %x) nounwind
1004   call void @use_pointer(i8* %x)
1005   call void @objc_release(i8* %x) nounwind
1006   ret void
1007 }
1008
1009 ; Trivial retain,release pair with intervening call, and it's post-dominated by
1010 ; another release. But it is not known safe in the top down direction. We can
1011 ; not eliminate it.
1012
1013 ; CHECK-LABEL: define void @test14(
1014 ; CHECK-NEXT: entry:
1015 ; CHECK-NEXT: @objc_retain
1016 ; CHECK-NEXT: @use_pointer
1017 ; CHECK-NEXT: @use_pointer
1018 ; CHECK-NEXT: @objc_release
1019 ; CHECK-NEXT: @objc_release
1020 ; CHECK-NEXT: ret void
1021 ; CHECK-NEXT: }
1022 define void @test14(i8* %x, i64 %n) {
1023 entry:
1024   call i8* @objc_retain(i8* %x) nounwind
1025   call void @use_pointer(i8* %x)
1026   call void @use_pointer(i8* %x)
1027   call void @objc_release(i8* %x) nounwind
1028   call void @objc_release(i8* %x) nounwind
1029   ret void
1030 }
1031
1032 ; Trivial retain,autorelease pair with intervening call, but it's post-dominated
1033 ; by another release. Don't delete anything.
1034
1035 ; CHECK-LABEL: define void @test15(
1036 ; CHECK-NEXT: entry:
1037 ; CHECK-NEXT: @objc_retain(i8* %x)
1038 ; CHECK-NEXT: @use_pointer
1039 ; CHECK-NEXT: @objc_autorelease(i8* %x)
1040 ; CHECK-NEXT: @objc_release
1041 ; CHECK-NEXT: ret void
1042 ; CHECK-NEXT: }
1043 define void @test15(i8* %x, i64 %n) {
1044 entry:
1045   call i8* @objc_retain(i8* %x) nounwind
1046   call void @use_pointer(i8* %x)
1047   call i8* @objc_autorelease(i8* %x) nounwind
1048   call void @objc_release(i8* %x) nounwind
1049   ret void
1050 }
1051
1052 ; Trivial retain,autorelease pair, post-dominated
1053 ; by another release. Delete the retain and release.
1054
1055 ; CHECK-LABEL: define void @test15b(
1056 ; CHECK-NEXT: entry:
1057 ; CHECK-NEXT: @objc_retain
1058 ; CHECK-NEXT: @objc_autorelease
1059 ; CHECK-NEXT: @objc_release
1060 ; CHECK-NEXT: ret void
1061 ; CHECK-NEXT: }
1062 define void @test15b(i8* %x, i64 %n) {
1063 entry:
1064   call i8* @objc_retain(i8* %x) nounwind
1065   call i8* @objc_autorelease(i8* %x) nounwind
1066   call void @objc_release(i8* %x) nounwind
1067   ret void
1068 }
1069
1070 ; CHECK-LABEL: define void @test15c(
1071 ; CHECK-NEXT: entry:
1072 ; CHECK-NEXT: @objc_autorelease
1073 ; CHECK-NEXT: ret void
1074 ; CHECK-NEXT: }
1075 define void @test15c(i8* %x, i64 %n) {
1076 entry:
1077   call i8* @objc_retain(i8* %x) nounwind
1078   call i8* @objc_autorelease(i8* %x) nounwind
1079   call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1080   ret void
1081 }
1082
1083 ; Retain+release pairs in diamonds, all dominated by a retain.
1084
1085 ; CHECK-LABEL: define void @test16a(
1086 ; CHECK: @objc_retain(i8* %x)
1087 ; CHECK-NOT: @objc
1088 ; CHECK: purple:
1089 ; CHECK: @use_pointer
1090 ; CHECK: @objc_release
1091 ; CHECK: }
1092 define void @test16a(i1 %a, i1 %b, i8* %x) {
1093 entry:
1094   call i8* @objc_retain(i8* %x) nounwind
1095   br i1 %a, label %red, label %orange
1096
1097 red:
1098   call i8* @objc_retain(i8* %x) nounwind
1099   br label %yellow
1100
1101 orange:
1102   call i8* @objc_retain(i8* %x) nounwind
1103   br label %yellow
1104
1105 yellow:
1106   call void @use_pointer(i8* %x)
1107   call void @use_pointer(i8* %x)
1108   br i1 %b, label %green, label %blue
1109
1110 green:
1111   call void @objc_release(i8* %x) nounwind
1112   br label %purple
1113
1114 blue:
1115   call void @objc_release(i8* %x) nounwind
1116   br label %purple
1117
1118 purple:
1119   call void @use_pointer(i8* %x)
1120   call void @objc_release(i8* %x) nounwind
1121   ret void
1122 }
1123
1124 ; CHECK-LABEL: define void @test16b(
1125 ; CHECK: @objc_retain(i8* %x)
1126 ; CHECK-NOT: @objc
1127 ; CHECK: purple:
1128 ; CHECK-NEXT: @use_pointer
1129 ; CHECK-NEXT: @use_pointer
1130 ; CHECK-NEXT: @objc_release
1131 ; CHECK: }
1132 define void @test16b(i1 %a, i1 %b, i8* %x) {
1133 entry:
1134   call i8* @objc_retain(i8* %x) nounwind
1135   br i1 %a, label %red, label %orange
1136
1137 red:
1138   call i8* @objc_retain(i8* %x) nounwind
1139   br label %yellow
1140
1141 orange:
1142   call i8* @objc_retain(i8* %x) nounwind
1143   br label %yellow
1144
1145 yellow:
1146   call void @use_pointer(i8* %x)
1147   call void @use_pointer(i8* %x)
1148   br i1 %b, label %green, label %blue
1149
1150 green:
1151   call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1152   br label %purple
1153
1154 blue:
1155   call void @objc_release(i8* %x) nounwind
1156   br label %purple
1157
1158 purple:
1159   call void @use_pointer(i8* %x)
1160   call void @use_pointer(i8* %x)
1161   call void @objc_release(i8* %x) nounwind
1162   ret void
1163 }
1164
1165 ; CHECK-LABEL: define void @test16c(
1166 ; CHECK: @objc_retain(i8* %x)
1167 ; CHECK-NOT: @objc
1168 ; CHECK: purple:
1169 ; CHECK: @use_pointer
1170 ; CHECK: @objc_release
1171 ; CHECK: }
1172 define void @test16c(i1 %a, i1 %b, i8* %x) {
1173 entry:
1174   call i8* @objc_retain(i8* %x) nounwind
1175   br i1 %a, label %red, label %orange
1176
1177 red:
1178   call i8* @objc_retain(i8* %x) nounwind
1179   br label %yellow
1180
1181 orange:
1182   call i8* @objc_retain(i8* %x) nounwind
1183   br label %yellow
1184
1185 yellow:
1186   call void @use_pointer(i8* %x)
1187   call void @use_pointer(i8* %x)
1188   br i1 %b, label %green, label %blue
1189
1190 green:
1191   call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1192   br label %purple
1193
1194 blue:
1195   call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1196   br label %purple
1197
1198 purple:
1199   call void @use_pointer(i8* %x)
1200   call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1201   ret void
1202 }
1203
1204 ; CHECK-LABEL: define void @test16d(
1205 ; CHECK: @objc_retain(i8* %x)
1206 ; CHECK: @objc
1207 ; CHECK: }
1208 define void @test16d(i1 %a, i1 %b, i8* %x) {
1209 entry:
1210   call i8* @objc_retain(i8* %x) nounwind
1211   br i1 %a, label %red, label %orange
1212
1213 red:
1214   call i8* @objc_retain(i8* %x) nounwind
1215   br label %yellow
1216
1217 orange:
1218   call i8* @objc_retain(i8* %x) nounwind
1219   br label %yellow
1220
1221 yellow:
1222   call void @use_pointer(i8* %x)
1223   call void @use_pointer(i8* %x)
1224   br i1 %b, label %green, label %blue
1225
1226 green:
1227   call void @objc_release(i8* %x) nounwind
1228   br label %purple
1229
1230 blue:
1231   call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1232   br label %purple
1233
1234 purple:
1235   ret void
1236 }
1237
1238 ; Delete no-ops.
1239
1240 ; CHECK-LABEL: define void @test18(
1241 ; CHECK-NOT: @objc_
1242 ; CHECK: }
1243 define void @test18() {
1244   call i8* @objc_retain(i8* null)
1245   call void @objc_release(i8* null)
1246   call i8* @objc_autorelease(i8* null)
1247   ret void
1248 }
1249
1250 ; Delete no-ops where undef can be assumed to be null.
1251
1252 ; CHECK-LABEL: define void @test18b(
1253 ; CHECK-NOT: @objc_
1254 ; CHECK: }
1255 define void @test18b() {
1256   call i8* @objc_retain(i8* undef)
1257   call void @objc_release(i8* undef)
1258   call i8* @objc_autorelease(i8* undef)
1259   ret void
1260 }
1261
1262 ; Replace uses of arguments with uses of return values, to reduce
1263 ; register pressure.
1264
1265 ; CHECK: define void @test19(i32* %y) {
1266 ; CHECK:   %z = bitcast i32* %y to i8*
1267 ; CHECK:   %0 = bitcast i32* %y to i8*
1268 ; CHECK:   %1 = tail call i8* @objc_retain(i8* %0)
1269 ; CHECK:   call void @use_pointer(i8* %z)
1270 ; CHECK:   call void @use_pointer(i8* %z)
1271 ; CHECK:   %2 = bitcast i32* %y to i8*
1272 ; CHECK:   call void @objc_release(i8* %2)
1273 ; CHECK:   ret void
1274 ; CHECK: }
1275 define void @test19(i32* %y) {
1276 entry:
1277   %x = bitcast i32* %y to i8*
1278   %0 = call i8* @objc_retain(i8* %x) nounwind
1279   %z = bitcast i32* %y to i8*
1280   call void @use_pointer(i8* %z)
1281   call void @use_pointer(i8* %z)
1282   call void @objc_release(i8* %x)
1283   ret void
1284 }
1285
1286 ; Bitcast insertion
1287
1288 ; CHECK-LABEL: define void @test20(
1289 ; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) [[NUW]]
1290 ; CHECK-NEXT: invoke
1291 ; CHECK: }
1292 define void @test20(double* %self) personality i32 (...)* @__gxx_personality_v0 {
1293 if.then12:
1294   %tmp = bitcast double* %self to i8*
1295   %tmp1 = call i8* @objc_retain(i8* %tmp) nounwind
1296   invoke void @invokee()
1297           to label %invoke.cont23 unwind label %lpad20
1298
1299 invoke.cont23:                                    ; preds = %if.then12
1300   invoke void @invokee()
1301           to label %if.end unwind label %lpad20
1302
1303 lpad20:                                           ; preds = %invoke.cont23, %if.then12
1304   %tmp502 = phi double* [ undef, %invoke.cont23 ], [ %self, %if.then12 ]
1305   %exn = landingpad {i8*, i32}
1306            cleanup
1307   unreachable
1308
1309 if.end:                                           ; preds = %invoke.cont23
1310   ret void
1311 }
1312
1313 ; Delete a redundant retain,autorelease when forwaring a call result
1314 ; directly to a return value.
1315
1316 ; CHECK-LABEL: define i8* @test21(
1317 ; CHECK: call i8* @returner()
1318 ; CHECK-NEXT: ret i8* %call
1319 ; CHECK-NEXT: }
1320 define i8* @test21() {
1321 entry:
1322   %call = call i8* @returner()
1323   %0 = call i8* @objc_retain(i8* %call) nounwind
1324   %1 = call i8* @objc_autorelease(i8* %0) nounwind
1325   ret i8* %1
1326 }
1327
1328 ; Move an objc call up through a phi that has null operands.
1329
1330 ; CHECK-LABEL: define void @test22(
1331 ; CHECK: B:
1332 ; CHECK:   %1 = bitcast double* %p to i8*
1333 ; CHECK:   call void @objc_release(i8* %1)
1334 ; CHECK:   br label %C
1335 ; CHECK: C:                                                ; preds = %B, %A
1336 ; CHECK-NOT: @objc_release
1337 ; CHECK: }
1338 define void @test22(double* %p, i1 %a) {
1339   br i1 %a, label %A, label %B
1340 A:
1341   br label %C
1342 B:
1343   br label %C
1344 C:
1345   %h = phi double* [ null, %A ], [ %p, %B ]
1346   %c = bitcast double* %h to i8*
1347   call void @objc_release(i8* %c)
1348   ret void
1349 }
1350
1351 ; Any call can decrement a retain count.
1352
1353 ; CHECK-LABEL: define void @test24(
1354 ; CHECK: @objc_retain(i8* %a)
1355 ; CHECK: @objc_release
1356 ; CHECK: }
1357 define void @test24(i8* %r, i8* %a) {
1358   call i8* @objc_retain(i8* %a)
1359   call void @use_pointer(i8* %r)
1360   %q = load i8, i8* %a
1361   call void @objc_release(i8* %a)
1362   ret void
1363 }
1364
1365 ; Don't move a retain/release pair if the release can be moved
1366 ; but the retain can't be moved to balance it.
1367
1368 ; CHECK-LABEL: define void @test25(
1369 ; CHECK: entry:
1370 ; CHECK:   call i8* @objc_retain(i8* %p)
1371 ; CHECK: true:
1372 ; CHECK: done:
1373 ; CHECK:   call void @objc_release(i8* %p)
1374 ; CHECK: }
1375 define void @test25(i8* %p, i1 %x) {
1376 entry:
1377   %f0 = call i8* @objc_retain(i8* %p)
1378   call void @callee()
1379   br i1 %x, label %true, label %done
1380
1381 true:
1382   store i8 0, i8* %p
1383   br label %done
1384
1385 done:
1386   call void @objc_release(i8* %p)
1387   ret void
1388 }
1389
1390 ; Don't move a retain/release pair if the retain can be moved
1391 ; but the release can't be moved to balance it.
1392
1393 ; CHECK-LABEL: define void @test26(
1394 ; CHECK: entry:
1395 ; CHECK:   call i8* @objc_retain(i8* %p)
1396 ; CHECK: true:
1397 ; CHECK: done:
1398 ; CHECK:   call void @objc_release(i8* %p)
1399 ; CHECK: }
1400 define void @test26(i8* %p, i1 %x) {
1401 entry:
1402   %f0 = call i8* @objc_retain(i8* %p)
1403   br i1 %x, label %true, label %done
1404
1405 true:
1406   call void @callee()
1407   br label %done
1408
1409 done:
1410   store i8 0, i8* %p
1411   call void @objc_release(i8* %p)
1412   ret void
1413 }
1414
1415 ; Don't sink the retain,release into the loop.
1416
1417 ; CHECK-LABEL: define void @test27(
1418 ; CHECK: entry:
1419 ; CHECK: call i8* @objc_retain(i8* %p)
1420 ; CHECK: loop:
1421 ; CHECK-NOT: @objc_
1422 ; CHECK: done:
1423 ; CHECK: call void @objc_release
1424 ; CHECK: }
1425 define void @test27(i8* %p, i1 %x, i1 %y) {
1426 entry:
1427   %f0 = call i8* @objc_retain(i8* %p)
1428   br i1 %x, label %loop, label %done
1429
1430 loop:
1431   call void @callee()
1432   store i8 0, i8* %p
1433   br i1 %y, label %done, label %loop
1434
1435 done:
1436   call void @objc_release(i8* %p)
1437   ret void
1438 }
1439
1440 ; Trivial code motion case: Triangle.
1441
1442 ; CHECK-LABEL: define void @test28(
1443 ; CHECK-NOT: @objc_
1444 ; CHECK: true:
1445 ; CHECK: call i8* @objc_retain(
1446 ; CHECK: call void @callee()
1447 ; CHECK: store
1448 ; CHECK: call void @objc_release
1449 ; CHECK: done:
1450 ; CHECK-NOT: @objc_
1451 ; CHECK: }
1452 define void @test28(i8* %p, i1 %x) {
1453 entry:
1454   %f0 = call i8* @objc_retain(i8* %p)
1455   br i1 %x, label %true, label %done
1456
1457 true:
1458   call void @callee()
1459   store i8 0, i8* %p
1460   br label %done
1461
1462 done:
1463   call void @objc_release(i8* %p), !clang.imprecise_release !0
1464   ret void
1465 }
1466
1467 ; Trivial code motion case: Triangle, but no metadata. Don't move past
1468 ; unrelated memory references!
1469
1470 ; CHECK-LABEL: define void @test28b(
1471 ; CHECK: call i8* @objc_retain(
1472 ; CHECK: true:
1473 ; CHECK-NOT: @objc_
1474 ; CHECK: call void @callee()
1475 ; CHECK-NOT: @objc_
1476 ; CHECK: store
1477 ; CHECK-NOT: @objc_
1478 ; CHECK: done:
1479 ; CHECK: @objc_release
1480 ; CHECK: }
1481 define void @test28b(i8* %p, i1 %x, i8* noalias %t) {
1482 entry:
1483   %f0 = call i8* @objc_retain(i8* %p)
1484   br i1 %x, label %true, label %done
1485
1486 true:
1487   call void @callee()
1488   store i8 0, i8* %p
1489   br label %done
1490
1491 done:
1492   store i8 0, i8* %t
1493   call void @objc_release(i8* %p)
1494   ret void
1495 }
1496
1497 ; Trivial code motion case: Triangle, with metadata. Do move past
1498 ; unrelated memory references! And preserve the metadata.
1499
1500 ; CHECK-LABEL: define void @test28c(
1501 ; CHECK-NOT: @objc_
1502 ; CHECK: true:
1503 ; CHECK: call i8* @objc_retain(
1504 ; CHECK: call void @callee()
1505 ; CHECK: store
1506 ; CHECK: call void @objc_release(i8* %p) [[NUW]], !clang.imprecise_release
1507 ; CHECK: done:
1508 ; CHECK-NOT: @objc_
1509 ; CHECK: }
1510 define void @test28c(i8* %p, i1 %x, i8* noalias %t) {
1511 entry:
1512   %f0 = call i8* @objc_retain(i8* %p)
1513   br i1 %x, label %true, label %done
1514
1515 true:
1516   call void @callee()
1517   store i8 0, i8* %p
1518   br label %done
1519
1520 done:
1521   store i8 0, i8* %t
1522   call void @objc_release(i8* %p), !clang.imprecise_release !0
1523   ret void
1524 }
1525
1526 ; Like test28. but with two releases.
1527
1528 ; CHECK-LABEL: define void @test29(
1529 ; CHECK-NOT: @objc_
1530 ; CHECK: true:
1531 ; CHECK: call i8* @objc_retain(
1532 ; CHECK: call void @callee()
1533 ; CHECK: store
1534 ; CHECK: call void @objc_release
1535 ; CHECK-NOT: @objc_release
1536 ; CHECK: done:
1537 ; CHECK-NOT: @objc_
1538 ; CHECK: ohno:
1539 ; CHECK-NOT: @objc_
1540 ; CHECK: }
1541 define void @test29(i8* %p, i1 %x, i1 %y) {
1542 entry:
1543   %f0 = call i8* @objc_retain(i8* %p)
1544   br i1 %x, label %true, label %done
1545
1546 true:
1547   call void @callee()
1548   store i8 0, i8* %p
1549   br i1 %y, label %done, label %ohno
1550
1551 done:
1552   call void @objc_release(i8* %p)
1553   ret void
1554
1555 ohno:
1556   call void @objc_release(i8* %p)
1557   ret void
1558 }
1559
1560 ; Basic case with the use and call in a diamond
1561 ; with an extra release.
1562
1563 ; CHECK-LABEL: define void @test30(
1564 ; CHECK-NOT: @objc_
1565 ; CHECK: true:
1566 ; CHECK: call i8* @objc_retain(
1567 ; CHECK: call void @callee()
1568 ; CHECK: store
1569 ; CHECK: call void @objc_release
1570 ; CHECK-NOT: @objc_release
1571 ; CHECK: false:
1572 ; CHECK-NOT: @objc_
1573 ; CHECK: done:
1574 ; CHECK-NOT: @objc_
1575 ; CHECK: ohno:
1576 ; CHECK-NOT: @objc_
1577 ; CHECK: }
1578 define void @test30(i8* %p, i1 %x, i1 %y, i1 %z) {
1579 entry:
1580   %f0 = call i8* @objc_retain(i8* %p)
1581   br i1 %x, label %true, label %false
1582
1583 true:
1584   call void @callee()
1585   store i8 0, i8* %p
1586   br i1 %y, label %done, label %ohno
1587
1588 false:
1589   br i1 %z, label %done, label %ohno
1590
1591 done:
1592   call void @objc_release(i8* %p)
1593   ret void
1594
1595 ohno:
1596   call void @objc_release(i8* %p)
1597   ret void
1598 }
1599
1600 ; Basic case with a mergeable release.
1601
1602 ; CHECK-LABEL: define void @test31(
1603 ; CHECK: call i8* @objc_retain(i8* %p)
1604 ; CHECK: call void @callee()
1605 ; CHECK: store
1606 ; CHECK: call void @objc_release
1607 ; CHECK-NOT: @objc_release
1608 ; CHECK: true:
1609 ; CHECK-NOT: @objc_release
1610 ; CHECK: false:
1611 ; CHECK-NOT: @objc_release
1612 ; CHECK: ret void
1613 ; CHECK-NOT: @objc_release
1614 ; CHECK: }
1615 define void @test31(i8* %p, i1 %x) {
1616 entry:
1617   %f0 = call i8* @objc_retain(i8* %p)
1618   call void @callee()
1619   store i8 0, i8* %p
1620   br i1 %x, label %true, label %false
1621 true:
1622   call void @objc_release(i8* %p)
1623   ret void
1624 false:
1625   call void @objc_release(i8* %p)
1626   ret void
1627 }
1628
1629 ; Don't consider bitcasts or getelementptrs direct uses.
1630
1631 ; CHECK-LABEL: define void @test32(
1632 ; CHECK-NOT: @objc_
1633 ; CHECK: true:
1634 ; CHECK: call i8* @objc_retain(
1635 ; CHECK: call void @callee()
1636 ; CHECK: store
1637 ; CHECK: call void @objc_release
1638 ; CHECK: done:
1639 ; CHECK-NOT: @objc_
1640 ; CHECK: }
1641 define void @test32(i8* %p, i1 %x) {
1642 entry:
1643   %f0 = call i8* @objc_retain(i8* %p)
1644   br i1 %x, label %true, label %done
1645
1646 true:
1647   call void @callee()
1648   store i8 0, i8* %p
1649   br label %done
1650
1651 done:
1652   %g = bitcast i8* %p to i8*
1653   %h = getelementptr i8, i8* %g, i64 0
1654   call void @objc_release(i8* %g)
1655   ret void
1656 }
1657
1658 ; Do consider icmps to be direct uses.
1659
1660 ; CHECK-LABEL: define void @test33(
1661 ; CHECK-NOT: @objc_
1662 ; CHECK: true:
1663 ; CHECK: call i8* @objc_retain(
1664 ; CHECK: call void @callee()
1665 ; CHECK: icmp
1666 ; CHECK: call void @objc_release
1667 ; CHECK: done:
1668 ; CHECK-NOT: @objc_
1669 ; CHECK: }
1670 define void @test33(i8* %p, i1 %x, i8* %y) {
1671 entry:
1672   %f0 = call i8* @objc_retain(i8* %p)
1673   br i1 %x, label %true, label %done
1674
1675 true:
1676   call void @callee()
1677   %v = icmp eq i8* %p, %y
1678   br label %done
1679
1680 done:
1681   %g = bitcast i8* %p to i8*
1682   %h = getelementptr i8, i8* %g, i64 0
1683   call void @objc_release(i8* %g)
1684   ret void
1685 }
1686
1687 ; Delete retain,release if there's just a possible dec and we have imprecise
1688 ; releases.
1689
1690 ; CHECK-LABEL: define void @test34a(
1691 ; CHECK:   call i8* @objc_retain
1692 ; CHECK: true:
1693 ; CHECK: done:
1694 ; CHECK: call void @objc_release
1695 ; CHECK: }
1696 define void @test34a(i8* %p, i1 %x, i8* %y) {
1697 entry:
1698   %f0 = call i8* @objc_retain(i8* %p)
1699   br i1 %x, label %true, label %done
1700
1701 true:
1702   call void @callee()
1703   br label %done
1704
1705 done:
1706   %g = bitcast i8* %p to i8*
1707   %h = getelementptr i8, i8* %g, i64 0
1708   call void @objc_release(i8* %g)
1709   ret void
1710 }
1711
1712 ; CHECK-LABEL: define void @test34b(
1713 ; CHECK-NOT: @objc_
1714 ; CHECK: }
1715 define void @test34b(i8* %p, i1 %x, i8* %y) {
1716 entry:
1717   %f0 = call i8* @objc_retain(i8* %p)
1718   br i1 %x, label %true, label %done
1719
1720 true:
1721   call void @callee()
1722   br label %done
1723
1724 done:
1725   %g = bitcast i8* %p to i8*
1726   %h = getelementptr i8, i8* %g, i64 0
1727   call void @objc_release(i8* %g), !clang.imprecise_release !0
1728   ret void
1729 }
1730
1731
1732 ; Delete retain,release if there's just a use and we do not have a precise
1733 ; release.
1734
1735 ; Precise.
1736 ; CHECK-LABEL: define void @test35a(
1737 ; CHECK: entry:
1738 ; CHECK:   call i8* @objc_retain
1739 ; CHECK: true:
1740 ; CHECK: done:
1741 ; CHECK:   call void @objc_release
1742 ; CHECK: }
1743 define void @test35a(i8* %p, i1 %x, i8* %y) {
1744 entry:
1745   %f0 = call i8* @objc_retain(i8* %p)
1746   br i1 %x, label %true, label %done
1747
1748 true:
1749   %v = icmp eq i8* %p, %y
1750   br label %done
1751
1752 done:
1753   %g = bitcast i8* %p to i8*
1754   %h = getelementptr i8, i8* %g, i64 0
1755   call void @objc_release(i8* %g)
1756   ret void
1757 }
1758
1759 ; Imprecise.
1760 ; CHECK-LABEL: define void @test35b(
1761 ; CHECK-NOT: @objc_
1762 ; CHECK: }
1763 define void @test35b(i8* %p, i1 %x, i8* %y) {
1764 entry:
1765   %f0 = call i8* @objc_retain(i8* %p)
1766   br i1 %x, label %true, label %done
1767
1768 true:
1769   %v = icmp eq i8* %p, %y
1770   br label %done
1771
1772 done:
1773   %g = bitcast i8* %p to i8*
1774   %h = getelementptr i8, i8* %g, i64 0
1775   call void @objc_release(i8* %g), !clang.imprecise_release !0
1776   ret void
1777 }
1778
1779 ; Delete a retain,release if there's no actual use and we have precise release.
1780
1781 ; CHECK-LABEL: define void @test36a(
1782 ; CHECK: @objc_retain
1783 ; CHECK: call void @callee()
1784 ; CHECK-NOT: @objc_
1785 ; CHECK: call void @callee()
1786 ; CHECK: @objc_release
1787 ; CHECK: }
1788 define void @test36a(i8* %p) {
1789 entry:
1790   call i8* @objc_retain(i8* %p)
1791   call void @callee()
1792   call void @callee()
1793   call void @objc_release(i8* %p)
1794   ret void
1795 }
1796
1797 ; Like test36, but with metadata.
1798
1799 ; CHECK-LABEL: define void @test36b(
1800 ; CHECK-NOT: @objc_
1801 ; CHECK: }
1802 define void @test36b(i8* %p) {
1803 entry:
1804   call i8* @objc_retain(i8* %p)
1805   call void @callee()
1806   call void @callee()
1807   call void @objc_release(i8* %p), !clang.imprecise_release !0
1808   ret void
1809 }
1810
1811 ; Be aggressive about analyzing phis to eliminate possible uses.
1812
1813 ; CHECK-LABEL: define void @test38(
1814 ; CHECK-NOT: @objc_
1815 ; CHECK: }
1816 define void @test38(i8* %p, i1 %u, i1 %m, i8* %z, i8* %y, i8* %x, i8* %w) {
1817 entry:
1818   call i8* @objc_retain(i8* %p)
1819   br i1 %u, label %true, label %false
1820 true:
1821   br i1 %m, label %a, label %b
1822 false:
1823   br i1 %m, label %c, label %d
1824 a:
1825   br label %e
1826 b:
1827   br label %e
1828 c:
1829   br label %f
1830 d:
1831   br label %f
1832 e:
1833   %j = phi i8* [ %z, %a ], [ %y, %b ]
1834   br label %g
1835 f:
1836   %k = phi i8* [ %w, %c ], [ %x, %d ]
1837   br label %g
1838 g:
1839   %h = phi i8* [ %j, %e ], [ %k, %f ]
1840   call void @use_pointer(i8* %h)
1841   call void @objc_release(i8* %p), !clang.imprecise_release !0
1842   ret void
1843 }
1844
1845 ; Delete retain,release pairs around loops.
1846
1847 ; CHECK-LABEL: define void @test39(
1848 ; CHECK-NOT: @objc_
1849 ; CHECK: }
1850 define void @test39(i8* %p) {
1851 entry:
1852   %0 = call i8* @objc_retain(i8* %p)
1853   br label %loop
1854
1855 loop:                                             ; preds = %loop, %entry
1856   br i1 undef, label %loop, label %exit
1857
1858 exit:                                             ; preds = %loop
1859   call void @objc_release(i8* %0), !clang.imprecise_release !0
1860   ret void
1861 }
1862
1863 ; Delete retain,release pairs around loops containing uses.
1864
1865 ; CHECK-LABEL: define void @test39b(
1866 ; CHECK-NOT: @objc_
1867 ; CHECK: }
1868 define void @test39b(i8* %p) {
1869 entry:
1870   %0 = call i8* @objc_retain(i8* %p)
1871   br label %loop
1872
1873 loop:                                             ; preds = %loop, %entry
1874   store i8 0, i8* %0
1875   br i1 undef, label %loop, label %exit
1876
1877 exit:                                             ; preds = %loop
1878   call void @objc_release(i8* %0), !clang.imprecise_release !0
1879   ret void
1880 }
1881
1882 ; Delete retain,release pairs around loops containing potential decrements.
1883
1884 ; CHECK-LABEL: define void @test39c(
1885 ; CHECK-NOT: @objc_
1886 ; CHECK: }
1887 define void @test39c(i8* %p) {
1888 entry:
1889   %0 = call i8* @objc_retain(i8* %p)
1890   br label %loop
1891
1892 loop:                                             ; preds = %loop, %entry
1893   call void @use_pointer(i8* %0)
1894   br i1 undef, label %loop, label %exit
1895
1896 exit:                                             ; preds = %loop
1897   call void @objc_release(i8* %0), !clang.imprecise_release !0
1898   ret void
1899 }
1900
1901 ; Delete retain,release pairs around loops even if
1902 ; the successors are in a different order.
1903
1904 ; CHECK-LABEL: define void @test40(
1905 ; CHECK-NOT: @objc_
1906 ; CHECK: }
1907 define void @test40(i8* %p) {
1908 entry:
1909   %0 = call i8* @objc_retain(i8* %p)
1910   br label %loop
1911
1912 loop:                                             ; preds = %loop, %entry
1913   call void @use_pointer(i8* %0)
1914   br i1 undef, label %exit, label %loop
1915
1916 exit:                                             ; preds = %loop
1917   call void @objc_release(i8* %0), !clang.imprecise_release !0
1918   ret void
1919 }
1920
1921 ; Do the known-incremented retain+release elimination even if the pointer
1922 ; is also autoreleased.
1923
1924 ; CHECK-LABEL: define void @test42(
1925 ; CHECK-NEXT: entry:
1926 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1927 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1928 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1929 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1930 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1931 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1932 ; CHECK-NEXT: call void @objc_release(i8* %p)
1933 ; CHECK-NEXT: ret void
1934 ; CHECK-NEXT: }
1935 define void @test42(i8* %p) {
1936 entry:
1937   call i8* @objc_retain(i8* %p)
1938   call i8* @objc_autorelease(i8* %p)
1939   call i8* @objc_retain(i8* %p)
1940   call void @use_pointer(i8* %p)
1941   call void @use_pointer(i8* %p)
1942   call void @objc_release(i8* %p)
1943   call void @use_pointer(i8* %p)
1944   call void @use_pointer(i8* %p)
1945   call void @objc_release(i8* %p)
1946   ret void
1947 }
1948
1949 ; Don't the known-incremented retain+release elimination if the pointer is
1950 ; autoreleased and there's an autoreleasePoolPop.
1951
1952 ; CHECK-LABEL: define void @test43(
1953 ; CHECK-NEXT: entry:
1954 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1955 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1956 ; CHECK-NEXT: call i8* @objc_retain
1957 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1958 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1959 ; CHECK-NEXT: call void @objc_autoreleasePoolPop(i8* undef)
1960 ; CHECK-NEXT: call void @objc_release
1961 ; CHECK-NEXT: ret void
1962 ; CHECK-NEXT: }
1963 define void @test43(i8* %p) {
1964 entry:
1965   call i8* @objc_retain(i8* %p)
1966   call i8* @objc_autorelease(i8* %p)
1967   call i8* @objc_retain(i8* %p)
1968   call void @use_pointer(i8* %p)
1969   call void @use_pointer(i8* %p)
1970   call void @objc_autoreleasePoolPop(i8* undef)
1971   call void @objc_release(i8* %p)
1972   ret void
1973 }
1974
1975 ; Do the known-incremented retain+release elimination if the pointer is
1976 ; autoreleased and there's an autoreleasePoolPush.
1977
1978 ; CHECK-LABEL: define void @test43b(
1979 ; CHECK-NEXT: entry:
1980 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1981 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1982 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1983 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1984 ; CHECK-NEXT: call i8* @objc_autoreleasePoolPush()
1985 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1986 ; CHECK-NEXT: call void @objc_release
1987 ; CHECK-NEXT: ret void
1988 ; CHECK-NEXT: }
1989 define void @test43b(i8* %p) {
1990 entry:
1991   call i8* @objc_retain(i8* %p)
1992   call i8* @objc_autorelease(i8* %p)
1993   call i8* @objc_retain(i8* %p)
1994   call void @use_pointer(i8* %p)
1995   call void @use_pointer(i8* %p)
1996   call i8* @objc_autoreleasePoolPush()
1997   call void @objc_release(i8* %p)
1998   call void @use_pointer(i8* %p)
1999   call void @objc_release(i8* %p)
2000   ret void
2001 }
2002
2003 ; Do retain+release elimination for non-provenance pointers.
2004
2005 ; CHECK-LABEL: define void @test44(
2006 ; CHECK-NOT: objc_
2007 ; CHECK: }
2008 define void @test44(i8** %pp) {
2009   %p = load i8*, i8** %pp
2010   %q = call i8* @objc_retain(i8* %p)
2011   call void @objc_release(i8* %q)
2012   ret void
2013 }
2014
2015 ; Don't delete retain+release with an unknown-provenance
2016 ; may-alias objc_release between them.
2017
2018 ; CHECK-LABEL: define void @test45(
2019 ; CHECK: call i8* @objc_retain(i8* %p)
2020 ; CHECK: call void @objc_release(i8* %q)
2021 ; CHECK: call void @use_pointer(i8* %p)
2022 ; CHECK: call void @objc_release(i8* %p)
2023 ; CHECK: }
2024 define void @test45(i8** %pp, i8** %qq) {
2025   %p = load i8*, i8** %pp
2026   %q = load i8*, i8** %qq
2027   call i8* @objc_retain(i8* %p)
2028   call void @objc_release(i8* %q)
2029   call void @use_pointer(i8* %p)
2030   call void @objc_release(i8* %p)
2031   ret void
2032 }
2033
2034 ; Don't delete retain and autorelease here.
2035
2036 ; CHECK-LABEL: define void @test46(
2037 ; CHECK: tail call i8* @objc_retain(i8* %p) [[NUW]]
2038 ; CHECK: true:
2039 ; CHECK: call i8* @objc_autorelease(i8* %p) [[NUW]]
2040 ; CHECK: }
2041 define void @test46(i8* %p, i1 %a) {
2042 entry:
2043   call i8* @objc_retain(i8* %p)
2044   br i1 %a, label %true, label %false
2045
2046 true:
2047   call i8* @objc_autorelease(i8* %p)
2048   call void @use_pointer(i8* %p)
2049   ret void
2050
2051 false:
2052   ret void
2053 }
2054
2055 ; Delete no-op cast calls.
2056
2057 ; CHECK-LABEL: define i8* @test47(
2058 ; CHECK-NOT: call
2059 ; CHECK: ret i8* %p
2060 ; CHECK: }
2061 define i8* @test47(i8* %p) nounwind {
2062   %x = call i8* @objc_retainedObject(i8* %p)
2063   ret i8* %x
2064 }
2065
2066 ; Delete no-op cast calls.
2067
2068 ; CHECK-LABEL: define i8* @test48(
2069 ; CHECK-NOT: call
2070 ; CHECK: ret i8* %p
2071 ; CHECK: }
2072 define i8* @test48(i8* %p) nounwind {
2073   %x = call i8* @objc_unretainedObject(i8* %p)
2074   ret i8* %x
2075 }
2076
2077 ; Delete no-op cast calls.
2078
2079 ; CHECK-LABEL: define i8* @test49(
2080 ; CHECK-NOT: call
2081 ; CHECK: ret i8* %p
2082 ; CHECK: }
2083 define i8* @test49(i8* %p) nounwind {
2084   %x = call i8* @objc_unretainedPointer(i8* %p)
2085   ret i8* %x
2086 }
2087
2088 ; Do delete retain+release with intervening stores of the address value if we
2089 ; have imprecise release attached to objc_release.
2090
2091 ; CHECK-LABEL:      define void @test50a(
2092 ; CHECK-NEXT:   call i8* @objc_retain
2093 ; CHECK-NEXT:   call void @callee
2094 ; CHECK-NEXT:   store
2095 ; CHECK-NEXT:   call void @objc_release
2096 ; CHECK-NEXT:   ret void
2097 ; CHECK-NEXT: }
2098 define void @test50a(i8* %p, i8** %pp) {
2099   call i8* @objc_retain(i8* %p)
2100   call void @callee()
2101   store i8* %p, i8** %pp
2102   call void @objc_release(i8* %p)
2103   ret void
2104 }
2105
2106 ; CHECK-LABEL: define void @test50b(
2107 ; CHECK-NOT: @objc_
2108 ; CHECK: }
2109 define void @test50b(i8* %p, i8** %pp) {
2110   call i8* @objc_retain(i8* %p)
2111   call void @callee()
2112   store i8* %p, i8** %pp
2113   call void @objc_release(i8* %p), !clang.imprecise_release !0
2114   ret void
2115 }
2116
2117
2118 ; Don't delete retain+release with intervening stores through the
2119 ; address value.
2120
2121 ; CHECK-LABEL: define void @test51a(
2122 ; CHECK: call i8* @objc_retain(i8* %p)
2123 ; CHECK: call void @objc_release(i8* %p)
2124 ; CHECK: ret void
2125 ; CHECK: }
2126 define void @test51a(i8* %p) {
2127   call i8* @objc_retain(i8* %p)
2128   call void @callee()
2129   store i8 0, i8* %p
2130   call void @objc_release(i8* %p)
2131   ret void
2132 }
2133
2134 ; CHECK-LABEL: define void @test51b(
2135 ; CHECK: call i8* @objc_retain(i8* %p)
2136 ; CHECK: call void @objc_release(i8* %p)
2137 ; CHECK: ret void
2138 ; CHECK: }
2139 define void @test51b(i8* %p) {
2140   call i8* @objc_retain(i8* %p)
2141   call void @callee()
2142   store i8 0, i8* %p
2143   call void @objc_release(i8* %p), !clang.imprecise_release !0
2144   ret void
2145 }
2146
2147 ; Don't delete retain+release with intervening use of a pointer of
2148 ; unknown provenance.
2149
2150 ; CHECK-LABEL: define void @test52a(
2151 ; CHECK: call i8* @objc_retain
2152 ; CHECK: call void @callee()
2153 ; CHECK: call void @use_pointer(i8* %z)
2154 ; CHECK: call void @objc_release
2155 ; CHECK: ret void
2156 ; CHECK: }
2157 define void @test52a(i8** %zz, i8** %pp) {
2158   %p = load i8*, i8** %pp
2159   %1 = call i8* @objc_retain(i8* %p)
2160   call void @callee()
2161   %z = load i8*, i8** %zz
2162   call void @use_pointer(i8* %z)
2163   call void @objc_release(i8* %p)
2164   ret void
2165 }
2166
2167 ; CHECK-LABEL: define void @test52b(
2168 ; CHECK: call i8* @objc_retain
2169 ; CHECK: call void @callee()
2170 ; CHECK: call void @use_pointer(i8* %z)
2171 ; CHECK: call void @objc_release
2172 ; CHECK: ret void
2173 ; CHECK: }
2174 define void @test52b(i8** %zz, i8** %pp) {
2175   %p = load i8*, i8** %pp
2176   %1 = call i8* @objc_retain(i8* %p)
2177   call void @callee()
2178   %z = load i8*, i8** %zz
2179   call void @use_pointer(i8* %z)
2180   call void @objc_release(i8* %p), !clang.imprecise_release !0
2181   ret void
2182 }
2183
2184 ; Like test52, but the pointer has function type, so it's assumed to
2185 ; be not reference counted.
2186 ; Oops. That's wrong. Clang sometimes uses function types gratuitously.
2187 ; See rdar://10551239.
2188
2189 ; CHECK-LABEL: define void @test53(
2190 ; CHECK: @objc_
2191 ; CHECK: }
2192 define void @test53(void ()** %zz, i8** %pp) {
2193   %p = load i8*, i8** %pp
2194   %1 = call i8* @objc_retain(i8* %p)
2195   call void @callee()
2196   %z = load void ()*, void ()** %zz
2197   call void @callee_fnptr(void ()* %z)
2198   call void @objc_release(i8* %p)
2199   ret void
2200 }
2201
2202 ; Convert autorelease to release if the value is unused.
2203
2204 ; CHECK-LABEL: define void @test54(
2205 ; CHECK: call i8* @returner()
2206 ; CHECK-NEXT: call void @objc_release(i8* %t) [[NUW]], !clang.imprecise_release ![[RELEASE]]
2207 ; CHECK-NEXT: ret void
2208 ; CHECK: }
2209 define void @test54() {
2210   %t = call i8* @returner()
2211   call i8* @objc_autorelease(i8* %t)
2212   ret void
2213 }
2214
2215 ; Nested retain+release pairs. Delete them both.
2216
2217 ; CHECK-LABEL: define void @test55(
2218 ; CHECK-NOT: @objc
2219 ; CHECK: }
2220 define void @test55(i8* %x) {
2221 entry:
2222   %0 = call i8* @objc_retain(i8* %x) nounwind
2223   %1 = call i8* @objc_retain(i8* %x) nounwind
2224   call void @objc_release(i8* %x) nounwind
2225   call void @objc_release(i8* %x) nounwind
2226   ret void
2227 }
2228
2229 ; Nested retain+release pairs where the inner pair depends
2230 ; on the outer pair to be removed, and then the outer pair
2231 ; can be partially eliminated. Plus an extra outer pair to
2232 ; eliminate, for fun.
2233
2234 ; CHECK-LABEL: define void @test56(
2235 ; CHECK-NOT: @objc
2236 ; CHECK: if.then:
2237 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
2238 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
2239 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
2240 ; CHECK-NEXT: tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE]]
2241 ; CHECK-NEXT: br label %if.end
2242 ; CHECK-NOT: @objc
2243 ; CHECK: }
2244 define void @test56(i8* %x, i32 %n) {
2245 entry:
2246   %0 = tail call i8* @objc_retain(i8* %x) nounwind
2247   %1 = tail call i8* @objc_retain(i8* %0) nounwind
2248   %tobool = icmp eq i32 %n, 0
2249   br i1 %tobool, label %if.end, label %if.then
2250
2251 if.then:                                          ; preds = %entry
2252   %2 = tail call i8* @objc_retain(i8* %1) nounwind
2253   tail call void @use_pointer(i8* %2)
2254   tail call void @use_pointer(i8* %2)
2255   tail call void @objc_release(i8* %2) nounwind, !clang.imprecise_release !0
2256   br label %if.end
2257
2258 if.end:                                           ; preds = %entry, %if.then
2259   tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
2260   tail call void @objc_release(i8* %0) nounwind, !clang.imprecise_release !0
2261   ret void
2262 }
2263
2264 ; When there are adjacent retain+release pairs, the first one is known
2265 ; unnecessary because the presence of the second one means that the first one
2266 ; won't be deleting the object.
2267
2268 ; CHECK-LABEL:      define void @test57(
2269 ; CHECK-NEXT: entry:
2270 ; CHECK-NEXT:   tail call i8* @objc_retain(i8* %x) [[NUW]]
2271 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2272 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2273 ; CHECK-NEXT:   tail call i8* @objc_retain(i8* %x) [[NUW]]
2274 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2275 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2276 ; CHECK-NEXT:   call void @objc_release(i8* %x) [[NUW]]
2277 ; CHECK-NEXT:   ret void
2278 ; CHECK-NEXT: }
2279 define void @test57(i8* %x) nounwind {
2280 entry:
2281   call i8* @objc_retain(i8* %x) nounwind
2282   call i8* @objc_retain(i8* %x) nounwind
2283   call void @use_pointer(i8* %x)
2284   call void @use_pointer(i8* %x)
2285   call void @objc_release(i8* %x) nounwind
2286   call i8* @objc_retain(i8* %x) nounwind
2287   call void @use_pointer(i8* %x)
2288   call void @use_pointer(i8* %x)
2289   call void @objc_release(i8* %x) nounwind
2290   ret void
2291 }
2292
2293 ; An adjacent retain+release pair is sufficient even if it will be
2294 ; removed itself.
2295
2296 ; CHECK-LABEL:      define void @test58(
2297 ; CHECK-NEXT: entry:
2298 ; CHECK-NEXT:   @objc_retain
2299 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2300 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2301 ; CHECK-NEXT:   ret void
2302 ; CHECK-NEXT: }
2303 define void @test58(i8* %x) nounwind {
2304 entry:
2305   call i8* @objc_retain(i8* %x) nounwind
2306   call i8* @objc_retain(i8* %x) nounwind
2307   call void @use_pointer(i8* %x)
2308   call void @use_pointer(i8* %x)
2309   call void @objc_release(i8* %x) nounwind
2310   call i8* @objc_retain(i8* %x) nounwind
2311   call void @objc_release(i8* %x) nounwind
2312   ret void
2313 }
2314
2315 ; Don't delete the second retain+release pair in an adjacent set.
2316
2317 ; CHECK-LABEL:      define void @test59(
2318 ; CHECK-NEXT: entry:
2319 ; CHECK-NEXT:   %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
2320 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2321 ; CHECK-NEXT:   call void @use_pointer(i8* %x)
2322 ; CHECK-NEXT:   call void @objc_release(i8* %x) [[NUW]]
2323 ; CHECK-NEXT:   ret void
2324 ; CHECK-NEXT: }
2325 define void @test59(i8* %x) nounwind {
2326 entry:
2327   %a = call i8* @objc_retain(i8* %x) nounwind
2328   call void @objc_release(i8* %x) nounwind
2329   %b = call i8* @objc_retain(i8* %x) nounwind
2330   call void @use_pointer(i8* %x)
2331   call void @use_pointer(i8* %x)
2332   call void @objc_release(i8* %x) nounwind
2333   ret void
2334 }
2335
2336 ; Constant pointers to objects don't need reference counting.
2337
2338 @constptr = external constant i8*
2339 @something = external global i8*
2340
2341 ; We have a precise lifetime retain/release here. We can not remove them since
2342 ; @something is not constant.
2343
2344 ; CHECK-LABEL: define void @test60a(
2345 ; CHECK: call i8* @objc_retain
2346 ; CHECK: call void @objc_release
2347 ; CHECK: }
2348 define void @test60a() {
2349   %t = load i8*, i8** @constptr
2350   %s = load i8*, i8** @something
2351   call i8* @objc_retain(i8* %s)
2352   call void @callee()
2353   call void @use_pointer(i8* %t)
2354   call void @objc_release(i8* %s)
2355   ret void
2356 }
2357
2358 ; CHECK-LABEL: define void @test60b(
2359 ; CHECK: call i8* @objc_retain
2360 ; CHECK-NOT: call i8* @objc_retain
2361 ; CHECK-NOT: call i8* @objc_release
2362 ; CHECK: }
2363 define void @test60b() {
2364   %t = load i8*, i8** @constptr
2365   %s = load i8*, i8** @something
2366   call i8* @objc_retain(i8* %t)
2367   call i8* @objc_retain(i8* %t)
2368   call void @callee()
2369   call void @use_pointer(i8* %s)
2370   call void @objc_release(i8* %t)
2371   ret void
2372 }
2373
2374 ; CHECK-LABEL: define void @test60c(
2375 ; CHECK-NOT: @objc_
2376 ; CHECK: }
2377 define void @test60c() {
2378   %t = load i8*, i8** @constptr
2379   %s = load i8*, i8** @something
2380   call i8* @objc_retain(i8* %t)
2381   call void @callee()
2382   call void @use_pointer(i8* %s)
2383   call void @objc_release(i8* %t), !clang.imprecise_release !0
2384   ret void
2385 }
2386
2387 ; CHECK-LABEL: define void @test60d(
2388 ; CHECK-NOT: @objc_
2389 ; CHECK: }
2390 define void @test60d() {
2391   %t = load i8*, i8** @constptr
2392   %s = load i8*, i8** @something
2393   call i8* @objc_retain(i8* %t)
2394   call void @callee()
2395   call void @use_pointer(i8* %s)
2396   call void @objc_release(i8* %t)
2397   ret void
2398 }
2399
2400 ; CHECK-LABEL: define void @test60e(
2401 ; CHECK-NOT: @objc_
2402 ; CHECK: }
2403 define void @test60e() {
2404   %t = load i8*, i8** @constptr
2405   %s = load i8*, i8** @something
2406   call i8* @objc_retain(i8* %t)
2407   call void @callee()
2408   call void @use_pointer(i8* %s)
2409   call void @objc_release(i8* %t), !clang.imprecise_release !0
2410   ret void
2411 }
2412
2413 ; Constant pointers to objects don't need to be considered related to other
2414 ; pointers.
2415
2416 ; CHECK-LABEL: define void @test61(
2417 ; CHECK-NOT: @objc_
2418 ; CHECK: }
2419 define void @test61() {
2420   %t = load i8*, i8** @constptr
2421   call i8* @objc_retain(i8* %t)
2422   call void @callee()
2423   call void @use_pointer(i8* %t)
2424   call void @objc_release(i8* %t)
2425   ret void
2426 }
2427
2428 ; Delete a retain matched by releases when one is inside the loop and the
2429 ; other is outside the loop.
2430
2431 ; CHECK-LABEL: define void @test62(
2432 ; CHECK-NOT: @objc_
2433 ; CHECK: }
2434 define void @test62(i8* %x, i1* %p) nounwind {
2435 entry:
2436   br label %loop
2437
2438 loop:
2439   call i8* @objc_retain(i8* %x)
2440   %q = load i1, i1* %p
2441   br i1 %q, label %loop.more, label %exit
2442
2443 loop.more:
2444   call void @objc_release(i8* %x)
2445   br label %loop
2446
2447 exit:
2448   call void @objc_release(i8* %x)
2449   ret void
2450 }
2451
2452 ; Like test62 but with no release in exit.
2453 ; Don't delete anything!
2454
2455 ; CHECK-LABEL: define void @test63(
2456 ; CHECK: loop:
2457 ; CHECK:   tail call i8* @objc_retain(i8* %x)
2458 ; CHECK: loop.more:
2459 ; CHECK:   call void @objc_release(i8* %x)
2460 ; CHECK: }
2461 define void @test63(i8* %x, i1* %p) nounwind {
2462 entry:
2463   br label %loop
2464
2465 loop:
2466   call i8* @objc_retain(i8* %x)
2467   %q = load i1, i1* %p
2468   br i1 %q, label %loop.more, label %exit
2469
2470 loop.more:
2471   call void @objc_release(i8* %x)
2472   br label %loop
2473
2474 exit:
2475   ret void
2476 }
2477
2478 ; Like test62 but with no release in loop.more.
2479 ; Don't delete anything!
2480
2481 ; CHECK-LABEL: define void @test64(
2482 ; CHECK: loop:
2483 ; CHECK:   tail call i8* @objc_retain(i8* %x)
2484 ; CHECK: exit:
2485 ; CHECK:   call void @objc_release(i8* %x)
2486 ; CHECK: }
2487 define void @test64(i8* %x, i1* %p) nounwind {
2488 entry:
2489   br label %loop
2490
2491 loop:
2492   call i8* @objc_retain(i8* %x)
2493   %q = load i1, i1* %p
2494   br i1 %q, label %loop.more, label %exit
2495
2496 loop.more:
2497   br label %loop
2498
2499 exit:
2500   call void @objc_release(i8* %x)
2501   ret void
2502 }
2503
2504 ; Move an autorelease past a phi with a null.
2505
2506 ; CHECK-LABEL: define i8* @test65(
2507 ; CHECK: if.then:
2508 ; CHECK:   call i8* @objc_autorelease(
2509 ; CHECK: return:
2510 ; CHECK-NOT: @objc_autorelease
2511 ; CHECK: }
2512 define i8* @test65(i1 %x) {
2513 entry:
2514   br i1 %x, label %return, label %if.then
2515
2516 if.then:                                          ; preds = %entry
2517   %c = call i8* @returner()
2518   %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2519   br label %return
2520
2521 return:                                           ; preds = %if.then, %entry
2522   %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2523   %q = call i8* @objc_autorelease(i8* %retval) nounwind
2524   ret i8* %retval
2525 }
2526
2527 ; Don't move an autorelease past an autorelease pool boundary.
2528
2529 ; CHECK-LABEL: define i8* @test65b(
2530 ; CHECK: if.then:
2531 ; CHECK-NOT: @objc_autorelease
2532 ; CHECK: return:
2533 ; CHECK:   call i8* @objc_autorelease(
2534 ; CHECK: }
2535 define i8* @test65b(i1 %x) {
2536 entry:
2537   %t = call i8* @objc_autoreleasePoolPush()
2538   br i1 %x, label %return, label %if.then
2539
2540 if.then:                                          ; preds = %entry
2541   %c = call i8* @returner()
2542   %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2543   br label %return
2544
2545 return:                                           ; preds = %if.then, %entry
2546   %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2547   call void @objc_autoreleasePoolPop(i8* %t)
2548   %q = call i8* @objc_autorelease(i8* %retval) nounwind
2549   ret i8* %retval
2550 }
2551
2552 ; Don't move an autoreleaseReuturnValue, which would break
2553 ; the RV optimization.
2554
2555 ; CHECK-LABEL: define i8* @test65c(
2556 ; CHECK: if.then:
2557 ; CHECK-NOT: @objc_autorelease
2558 ; CHECK: return:
2559 ; CHECK:   call i8* @objc_autoreleaseReturnValue(
2560 ; CHECK: }
2561 define i8* @test65c(i1 %x) {
2562 entry:
2563   br i1 %x, label %return, label %if.then
2564
2565 if.then:                                          ; preds = %entry
2566   %c = call i8* @returner()
2567   %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2568   br label %return
2569
2570 return:                                           ; preds = %if.then, %entry
2571   %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2572   %q = call i8* @objc_autoreleaseReturnValue(i8* %retval) nounwind
2573   ret i8* %retval
2574 }
2575
2576 ; An objc_retain can serve as a may-use for a different pointer.
2577 ; rdar://11931823
2578
2579 ; CHECK-LABEL: define void @test66a(
2580 ; CHECK:   tail call i8* @objc_retain(i8* %cond) [[NUW]]
2581 ; CHECK:   tail call void @objc_release(i8* %call) [[NUW]]
2582 ; CHECK:   tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2583 ; CHECK:   tail call void @objc_release(i8* %cond) [[NUW]]
2584 ; CHECK: }
2585 define void @test66a(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2586 entry:
2587   br i1 %tobool, label %cond.true, label %cond.end
2588
2589 cond.true:
2590   br label %cond.end
2591
2592 cond.end:                                         ; preds = %cond.true, %entry
2593   %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2594   %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2595   tail call void @objc_release(i8* %call) nounwind
2596   %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2597   %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2598   tail call void @objc_release(i8* %cond) nounwind
2599   ret void
2600 }
2601
2602 ; CHECK-LABEL: define void @test66b(
2603 ; CHECK:   tail call i8* @objc_retain(i8* %cond) [[NUW]]
2604 ; CHECK:   tail call void @objc_release(i8* %call) [[NUW]]
2605 ; CHECK:   tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2606 ; CHECK:   tail call void @objc_release(i8* %cond) [[NUW]]
2607 ; CHECK: }
2608 define void @test66b(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2609 entry:
2610   br i1 %tobool, label %cond.true, label %cond.end
2611
2612 cond.true:
2613   br label %cond.end
2614
2615 cond.end:                                         ; preds = %cond.true, %entry
2616   %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2617   %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2618   tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
2619   %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2620   %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2621   tail call void @objc_release(i8* %cond) nounwind
2622   ret void
2623 }
2624
2625 ; CHECK-LABEL: define void @test66c(
2626 ; CHECK:   tail call i8* @objc_retain(i8* %cond) [[NUW]]
2627 ; CHECK:   tail call void @objc_release(i8* %call) [[NUW]]
2628 ; CHECK:   tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2629 ; CHECK:   tail call void @objc_release(i8* %cond) [[NUW]]
2630 ; CHECK: }
2631 define void @test66c(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2632 entry:
2633   br i1 %tobool, label %cond.true, label %cond.end
2634
2635 cond.true:
2636   br label %cond.end
2637
2638 cond.end:                                         ; preds = %cond.true, %entry
2639   %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2640   %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2641   tail call void @objc_release(i8* %call) nounwind
2642   %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2643   %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind, !clang.imprecise_release !0
2644   tail call void @objc_release(i8* %cond) nounwind
2645   ret void
2646 }
2647
2648 ; CHECK-LABEL: define void @test66d(
2649 ; CHECK:   tail call i8* @objc_retain(i8* %cond) [[NUW]]
2650 ; CHECK:   tail call void @objc_release(i8* %call) [[NUW]]
2651 ; CHECK:   tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2652 ; CHECK:   tail call void @objc_release(i8* %cond) [[NUW]]
2653 ; CHECK: }
2654 define void @test66d(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2655 entry:
2656   br i1 %tobool, label %cond.true, label %cond.end
2657
2658 cond.true:
2659   br label %cond.end
2660
2661 cond.end:                                         ; preds = %cond.true, %entry
2662   %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2663   %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2664   tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
2665   %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2666   %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2667   tail call void @objc_release(i8* %cond) nounwind, !clang.imprecise_release !0
2668   ret void
2669 }
2670
2671 ; A few real-world testcases.
2672
2673 @.str4 = private unnamed_addr constant [33 x i8] c"-[A z] = { %f, %f, { %f, %f } }\0A\00"
2674 @"OBJC_IVAR_$_A.myZ" = global i64 20, section "__DATA, __objc_const", align 8
2675 declare i32 @printf(i8* nocapture, ...) nounwind
2676 declare i32 @puts(i8* nocapture) nounwind
2677 @str = internal constant [16 x i8] c"-[ Top0 _getX ]\00"
2678
2679 ; CHECK: define { <2 x float>, <2 x float> } @"\01-[A z]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
2680 ; CHECK-NOT: @objc_
2681 ; CHECK: }
2682
2683 define {<2 x float>, <2 x float>} @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind {
2684 invoke.cont:
2685   %0 = bitcast {}* %self to i8*
2686   %1 = tail call i8* @objc_retain(i8* %0) nounwind
2687   tail call void @llvm.dbg.value(metadata {}* %self, i64 0, metadata !DILocalVariable(scope: !2), metadata !DIExpression()), !dbg !DILocation(scope: !2)
2688   tail call void @llvm.dbg.value(metadata {}* %self, i64 0, metadata !DILocalVariable(scope: !2), metadata !DIExpression()), !dbg !DILocation(scope: !2)
2689   %ivar = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
2690   %add.ptr = getelementptr i8, i8* %0, i64 %ivar
2691   %tmp1 = bitcast i8* %add.ptr to float*
2692   %tmp2 = load float, float* %tmp1, align 4
2693   %conv = fpext float %tmp2 to double
2694   %add.ptr.sum = add i64 %ivar, 4
2695   %tmp6 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum
2696   %2 = bitcast i8* %tmp6 to float*
2697   %tmp7 = load float, float* %2, align 4
2698   %conv8 = fpext float %tmp7 to double
2699   %add.ptr.sum36 = add i64 %ivar, 8
2700   %tmp12 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum36
2701   %arrayidx = bitcast i8* %tmp12 to float*
2702   %tmp13 = load float, float* %arrayidx, align 4
2703   %conv14 = fpext float %tmp13 to double
2704   %tmp12.sum = add i64 %ivar, 12
2705   %arrayidx19 = getelementptr inbounds i8, i8* %0, i64 %tmp12.sum
2706   %3 = bitcast i8* %arrayidx19 to float*
2707   %tmp20 = load float, float* %3, align 4
2708   %conv21 = fpext float %tmp20 to double
2709   %call = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str4, i64 0, i64 0), double %conv, double %conv8, double %conv14, double %conv21)
2710   %ivar23 = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
2711   %add.ptr24 = getelementptr i8, i8* %0, i64 %ivar23
2712   %4 = bitcast i8* %add.ptr24 to i128*
2713   %srcval = load i128, i128* %4, align 4
2714   tail call void @objc_release(i8* %0) nounwind
2715   %tmp29 = trunc i128 %srcval to i64
2716   %tmp30 = bitcast i64 %tmp29 to <2 x float>
2717   %tmp31 = insertvalue {<2 x float>, <2 x float>} undef, <2 x float> %tmp30, 0
2718   %tmp32 = lshr i128 %srcval, 64
2719   %tmp33 = trunc i128 %tmp32 to i64
2720   %tmp34 = bitcast i64 %tmp33 to <2 x float>
2721   %tmp35 = insertvalue {<2 x float>, <2 x float>} %tmp31, <2 x float> %tmp34, 1
2722   ret {<2 x float>, <2 x float>} %tmp35
2723 }
2724
2725 ; CHECK: @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
2726 ; CHECK-NOT: @objc_
2727 ; CHECK: }
2728
2729 define i32 @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) nounwind {
2730 invoke.cont:
2731   %0 = bitcast {}* %self to i8*
2732   %1 = tail call i8* @objc_retain(i8* %0) nounwind
2733   %puts = tail call i32 @puts(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str, i64 0, i64 0))
2734   tail call void @objc_release(i8* %0) nounwind
2735   ret i32 0
2736 }
2737
2738 @"\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], [5 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2739 @"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip"
2740 @llvm.used = appending global [3 x i8*] [i8* getelementptr inbounds ([5 x i8], [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"
2741
2742 ; A simple loop. Eliminate the retain and release inside of it!
2743
2744 ; CHECK: define void @loop(i8* %x, i64 %n) {
2745 ; CHECK: for.body:
2746 ; CHECK-NOT: @objc_
2747 ; CHECK: @objc_msgSend
2748 ; CHECK-NOT: @objc_
2749 ; CHECK: for.end:
2750 ; CHECK: }
2751 define void @loop(i8* %x, i64 %n) {
2752 entry:
2753   %0 = tail call i8* @objc_retain(i8* %x) nounwind
2754   %cmp9 = icmp sgt i64 %n, 0
2755   br i1 %cmp9, label %for.body, label %for.end
2756
2757 for.body:                                         ; preds = %entry, %for.body
2758   %i.010 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
2759   %1 = tail call i8* @objc_retain(i8* %x) nounwind
2760   %tmp5 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8
2761   %call = tail call i8* (i8*, i8*, ...) @objc_msgSend(i8* %1, i8* %tmp5)
2762   tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
2763   %inc = add nsw i64 %i.010, 1
2764   %exitcond = icmp eq i64 %inc, %n
2765   br i1 %exitcond, label %for.end, label %for.body
2766
2767 for.end:                                          ; preds = %for.body, %entry
2768   tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
2769   ret void
2770 }
2771
2772 ; ObjCARCOpt can delete the retain,release on self.
2773
2774 ; CHECK: define void @TextEditTest(%2* %self, %3* %pboard) {
2775 ; CHECK-NOT: call i8* @objc_retain(i8* %tmp7)
2776 ; CHECK: }
2777
2778 %0 = type { i8* (i8*, %struct._message_ref_t*, ...)*, i8* }
2779 %1 = type opaque
2780 %2 = type opaque
2781 %3 = type opaque
2782 %4 = type opaque
2783 %5 = type opaque
2784 %struct.NSConstantString = type { i32*, i32, i8*, i64 }
2785 %struct._NSRange = type { i64, i64 }
2786 %struct.__CFString = type opaque
2787 %struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
2788 %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* }
2789 %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
2790 %struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
2791 %struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
2792 %struct._message_ref_t = type { i8*, i8* }
2793 %struct._objc_cache = type opaque
2794 %struct._objc_method = type { i8*, i8*, i8* }
2795 %struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
2796 %struct._prop_list_t = type { i32, i32, [0 x %struct._message_ref_t] }
2797 %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 }
2798
2799 @"\01L_OBJC_CLASSLIST_REFERENCES_$_17" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2800 @kUTTypePlainText = external constant %struct.__CFString*
2801 @"\01L_OBJC_SELECTOR_REFERENCES_19" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2802 @"\01L_OBJC_SELECTOR_REFERENCES_21" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2803 @"\01L_OBJC_SELECTOR_REFERENCES_23" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2804 @"\01L_OBJC_SELECTOR_REFERENCES_25" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2805 @"\01L_OBJC_CLASSLIST_REFERENCES_$_26" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2806 @"\01L_OBJC_SELECTOR_REFERENCES_28" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2807 @"\01L_OBJC_CLASSLIST_REFERENCES_$_29" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2808 @"\01L_OBJC_SELECTOR_REFERENCES_31" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2809 @"\01L_OBJC_SELECTOR_REFERENCES_33" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2810 @"\01L_OBJC_SELECTOR_REFERENCES_35" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2811 @"\01L_OBJC_SELECTOR_REFERENCES_37" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2812 @"\01L_OBJC_CLASSLIST_REFERENCES_$_38" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2813 @"\01L_OBJC_SELECTOR_REFERENCES_40" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2814 @"\01L_OBJC_SELECTOR_REFERENCES_42" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2815 @_unnamed_cfstring_44 = external hidden constant %struct.NSConstantString, section "__DATA,__cfstring"
2816 @"\01L_OBJC_SELECTOR_REFERENCES_46" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2817 @"\01L_OBJC_SELECTOR_REFERENCES_48" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2818 @"\01l_objc_msgSend_fixup_isEqual_" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16
2819 @"\01L_OBJC_CLASSLIST_REFERENCES_$_50" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2820 @NSCocoaErrorDomain = external constant %1*
2821 @"\01L_OBJC_CLASSLIST_REFERENCES_$_51" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2822 @NSFilePathErrorKey = external constant %1*
2823 @"\01L_OBJC_SELECTOR_REFERENCES_53" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2824 @"\01L_OBJC_SELECTOR_REFERENCES_55" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2825 @"\01L_OBJC_CLASSLIST_REFERENCES_$_56" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2826 @"\01L_OBJC_SELECTOR_REFERENCES_58" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2827 @"\01L_OBJC_SELECTOR_REFERENCES_60" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2828
2829 declare %1* @truncatedString(%1*, i64)
2830 define void @TextEditTest(%2* %self, %3* %pboard) {
2831 entry:
2832   %err = alloca %4*, align 8
2833   %tmp7 = bitcast %2* %self to i8*
2834   %tmp8 = call i8* @objc_retain(i8* %tmp7) nounwind
2835   store %4* null, %4** %err, align 8
2836   %tmp1 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_17", align 8
2837   %tmp2 = load %struct.__CFString*, %struct.__CFString** @kUTTypePlainText, align 8
2838   %tmp3 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_19", align 8
2839   %tmp4 = bitcast %struct._class_t* %tmp1 to i8*
2840   %call5 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp4, i8* %tmp3, %struct.__CFString* %tmp2)
2841   %tmp5 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_21", align 8
2842   %tmp6 = bitcast %3* %pboard to i8*
2843   %call76 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp6, i8* %tmp5, i8* %call5)
2844   %tmp9 = call i8* @objc_retain(i8* %call76) nounwind
2845   %tobool = icmp eq i8* %tmp9, null
2846   br i1 %tobool, label %end, label %land.lhs.true
2847
2848 land.lhs.true:                                    ; preds = %entry
2849   %tmp11 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_23", align 8
2850   %call137 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp6, i8* %tmp11, i8* %tmp9)
2851   %tmp = bitcast i8* %call137 to %1*
2852   %tmp10 = call i8* @objc_retain(i8* %call137) nounwind
2853   call void @objc_release(i8* null) nounwind
2854   %tmp12 = call i8* @objc_retain(i8* %call137) nounwind
2855   call void @objc_release(i8* null) nounwind
2856   %tobool16 = icmp eq i8* %call137, null
2857   br i1 %tobool16, label %end, label %if.then
2858
2859 if.then:                                          ; preds = %land.lhs.true
2860   %tmp19 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
2861   %call21 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %call137, i8* %tmp19)
2862   %tobool22 = icmp eq i8 %call21, 0
2863   br i1 %tobool22, label %if.then44, label %land.lhs.true23
2864
2865 land.lhs.true23:                                  ; preds = %if.then
2866   %tmp24 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
2867   %tmp26 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
2868   %tmp27 = bitcast %struct._class_t* %tmp24 to i8*
2869   %call2822 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp27, i8* %tmp26, i8* %call137)
2870   %tmp13 = bitcast i8* %call2822 to %5*
2871   %tmp14 = call i8* @objc_retain(i8* %call2822) nounwind
2872   call void @objc_release(i8* null) nounwind
2873   %tobool30 = icmp eq i8* %call2822, null
2874   br i1 %tobool30, label %if.then44, label %if.end
2875
2876 if.end:                                           ; preds = %land.lhs.true23
2877   %tmp32 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
2878   %tmp33 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
2879   %tmp34 = bitcast %struct._class_t* %tmp32 to i8*
2880   %call35 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp34, i8* %tmp33)
2881   %tmp37 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
2882   %call3923 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call35, i8* %tmp37, i8* %call2822, i32 signext 1, %4** %err)
2883   %cmp = icmp eq i8* %call3923, null
2884   br i1 %cmp, label %if.then44, label %end
2885
2886 if.then44:                                        ; preds = %if.end, %land.lhs.true23, %if.then
2887   %url.025 = phi %5* [ %tmp13, %if.end ], [ %tmp13, %land.lhs.true23 ], [ null, %if.then ]
2888   %tmp49 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_35", align 8
2889   %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)
2890   %call513 = extractvalue %struct._NSRange %call51, 0
2891   %call514 = extractvalue %struct._NSRange %call51, 1
2892   %tmp52 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_37", align 8
2893   %call548 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call137, i8* %tmp52, i64 %call513, i64 %call514)
2894   %tmp55 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_38", align 8
2895   %tmp56 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_40", align 8
2896   %tmp57 = bitcast %struct._class_t* %tmp55 to i8*
2897   %call58 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp57, i8* %tmp56)
2898   %tmp59 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_42", align 8
2899   %call6110 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call548, i8* %tmp59, i8* %call58)
2900   %tmp15 = call i8* @objc_retain(i8* %call6110) nounwind
2901   call void @objc_release(i8* %call137) nounwind
2902   %tmp64 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_46", align 8
2903   %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*))
2904   %tobool67 = icmp eq i8 %call66, 0
2905   br i1 %tobool67, label %if.end74, label %if.then68
2906
2907 if.then68:                                        ; preds = %if.then44
2908   %tmp70 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_48", align 8
2909   %call7220 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call6110, i8* %tmp70)
2910   %tmp16 = call i8* @objc_retain(i8* %call7220) nounwind
2911   call void @objc_release(i8* %call6110) nounwind
2912   br label %if.end74
2913
2914 if.end74:                                         ; preds = %if.then68, %if.then44
2915   %filename.0.in = phi i8* [ %call7220, %if.then68 ], [ %call6110, %if.then44 ]
2916   %filename.0 = bitcast i8* %filename.0.in to %1*
2917   %tmp17 = load i8*, i8** bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to i8**), align 16
2918   %tmp18 = bitcast i8* %tmp17 to i8 (i8*, %struct._message_ref_t*, i8*, ...)*
2919   %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)
2920   %tobool79 = icmp eq i8 %call78, 0
2921   br i1 %tobool79, label %land.lhs.true80, label %if.then109
2922
2923 land.lhs.true80:                                  ; preds = %if.end74
2924   %tmp82 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
2925   %call84 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %filename.0.in, i8* %tmp82)
2926   %tobool86 = icmp eq i8 %call84, 0
2927   br i1 %tobool86, label %if.then109, label %if.end106
2928
2929 if.end106:                                        ; preds = %land.lhs.true80
2930   %tmp88 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
2931   %tmp90 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
2932   %tmp91 = bitcast %struct._class_t* %tmp88 to i8*
2933   %call9218 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp91, i8* %tmp90, i8* %filename.0.in)
2934   %tmp20 = bitcast i8* %call9218 to %5*
2935   %tmp21 = call i8* @objc_retain(i8* %call9218) nounwind
2936   %tmp22 = bitcast %5* %url.025 to i8*
2937   call void @objc_release(i8* %tmp22) nounwind
2938   %tmp94 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
2939   %tmp95 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
2940   %tmp96 = bitcast %struct._class_t* %tmp94 to i8*
2941   %call97 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp96, i8* %tmp95)
2942   %tmp99 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
2943   %call10119 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call97, i8* %tmp99, i8* %call9218, i32 signext 1, %4** %err)
2944   %phitmp = icmp eq i8* %call10119, null
2945   br i1 %phitmp, label %if.then109, label %end
2946
2947 if.then109:                                       ; preds = %if.end106, %land.lhs.true80, %if.end74
2948   %url.129 = phi %5* [ %tmp20, %if.end106 ], [ %url.025, %if.end74 ], [ %url.025, %land.lhs.true80 ]
2949   %tmp110 = load %4*, %4** %err, align 8
2950   %tobool111 = icmp eq %4* %tmp110, null
2951   br i1 %tobool111, label %if.then112, label %if.end125
2952
2953 if.then112:                                       ; preds = %if.then109
2954   %tmp113 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_50", align 8
2955   %tmp114 = load %1*, %1** @NSCocoaErrorDomain, align 8
2956   %tmp115 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_51", align 8
2957   %call117 = call %1* @truncatedString(%1* %filename.0, i64 1034)
2958   %tmp118 = load %1*, %1** @NSFilePathErrorKey, align 8
2959   %tmp119 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_53", align 8
2960   %tmp120 = bitcast %struct._class_t* %tmp115 to i8*
2961   %call12113 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp120, i8* %tmp119, %1* %call117, %1* %tmp118, i8* null)
2962   %tmp122 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_55", align 8
2963   %tmp123 = bitcast %struct._class_t* %tmp113 to i8*
2964   %call12414 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp123, i8* %tmp122, %1* %tmp114, i64 258, i8* %call12113)
2965   %tmp23 = call i8* @objc_retain(i8* %call12414) nounwind
2966   %tmp25 = call i8* @objc_autorelease(i8* %tmp23) nounwind
2967   %tmp28 = bitcast i8* %tmp25 to %4*
2968   store %4* %tmp28, %4** %err, align 8
2969   br label %if.end125
2970
2971 if.end125:                                        ; preds = %if.then112, %if.then109
2972   %tmp127 = phi %4* [ %tmp110, %if.then109 ], [ %tmp28, %if.then112 ]
2973   %tmp126 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_56", align 8
2974   %tmp128 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_58", align 8
2975   %tmp129 = bitcast %struct._class_t* %tmp126 to i8*
2976   %call13015 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp129, i8* %tmp128, %4* %tmp127)
2977   %tmp131 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_60", align 8
2978   %call13317 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call13015, i8* %tmp131)
2979   br label %end
2980
2981 end:                                              ; preds = %if.end125, %if.end106, %if.end, %land.lhs.true, %entry
2982   %filename.2 = phi %1* [ %filename.0, %if.end106 ], [ %filename.0, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
2983   %origFilename.0 = phi %1* [ %tmp, %if.end106 ], [ %tmp, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
2984   %url.2 = phi %5* [ %tmp20, %if.end106 ], [ %url.129, %if.end125 ], [ null, %land.lhs.true ], [ null, %entry ], [ %tmp13, %if.end ]
2985   call void @objc_release(i8* %tmp9) nounwind, !clang.imprecise_release !0
2986   %tmp29 = bitcast %5* %url.2 to i8*
2987   call void @objc_release(i8* %tmp29) nounwind, !clang.imprecise_release !0
2988   %tmp30 = bitcast %1* %origFilename.0 to i8*
2989   call void @objc_release(i8* %tmp30) nounwind, !clang.imprecise_release !0
2990   %tmp31 = bitcast %1* %filename.2 to i8*
2991   call void @objc_release(i8* %tmp31) nounwind, !clang.imprecise_release !0
2992   call void @objc_release(i8* %tmp7) nounwind, !clang.imprecise_release !0
2993   ret void
2994 }
2995
2996 declare i32 @__gxx_personality_v0(...)
2997
2998 declare i32 @objc_sync_enter(i8*)
2999 declare i32 @objc_sync_exit(i8*)
3000
3001 ; Make sure that we understand that objc_sync_{enter,exit} are IC_User not
3002 ; IC_Call/IC_CallOrUser.
3003
3004 ; CHECK-LABEL:      define void @test67(
3005 ; CHECK-NEXT:   call i32 @objc_sync_enter(i8* %x)
3006 ; CHECK-NEXT:   call i32 @objc_sync_exit(i8* %x)
3007 ; CHECK-NEXT:   ret void
3008 ; CHECK-NEXT: }
3009 define void @test67(i8* %x) {
3010   call i8* @objc_retain(i8* %x)
3011   call i32 @objc_sync_enter(i8* %x)
3012   call i32 @objc_sync_exit(i8* %x)
3013   call void @objc_release(i8* %x), !clang.imprecise_release !0
3014   ret void
3015 }
3016
3017 !llvm.module.flags = !{!1}
3018
3019 !0 = !{}
3020 !1 = !{i32 1, !"Debug Info Version", i32 3}
3021 !2 = distinct !DISubprogram()
3022
3023 ; CHECK: attributes #0 = { nounwind readnone }
3024 ; CHECK: attributes [[NUW]] = { nounwind }
3025 ; CHECK: ![[RELEASE]] = !{}