6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-24 09:29:42 +00:00
Code Issues Projects Releases Wiki Activity
69688b956a
llvm-6502/test/Transforms/ObjCARC/basic.ll
Michael Gottesman 6bc127e1dd [objc-arc] Make the ARC optimizer more conservative by forcing it to be non-safe in both direction, but mitigate the problem by noting that we just care if there was a further use. 
The problem here is the infamous one direction known safe. I was
hesitant to turn it off before b/c of the potential for regressions
without an actual bug from users hitting the problem. This is that bug ;
).

The main performance impact of having known safe in both directions is
that often times it is very difficult to find two releases without a use
in-between them since we are so conservative with determining potential
uses. The one direction known safe gets around that problem by taking
advantage of many situations where we have two retains in a row,
allowing us to avoid that problem. That being said, the one direction
known safe is unsafe. Consider the following situation:

retain(x)
retain(x)
call(x)
call(x)
release(x)

Then we know the following about the reference count of x:

// rc(x) == N (for some N).
retain(x)
// rc(x) == N+1
retain(x)
// rc(x) == N+2
call A(x)
call B(x)
// rc(x) >= 1 (since we can not release a deallocated pointer).
release(x)
// rc(x) >= 0

That is all the information that we can know statically. That means that
we know that A(x), B(x) together can release (x) at most N+1 times. Lets
say that we remove the inner retain, release pair.

// rc(x) == N (for some N).
retain(x)
// rc(x) == N+1
call A(x)
call B(x)
// rc(x) >= 1
release(x)
// rc(x) >= 0

We knew before that A(x), B(x) could release x up to N+1 times meaning
that rc(x) may be zero at the release(x). That is not safe. On the other
hand, consider the following situation where we have a must use of
release(x) that x must be kept alive for after the release(x)**. Then we
know that:

// rc(x) == N (for some N).
retain(x)
// rc(x) == N+1
retain(x)
// rc(x) == N+2
call A(x)
call B(x)
// rc(x) >= 2 (since we know that we are going to release x and that that release can not be the last use of x).
release(x)
// rc(x) >= 1 (since we can not deallocate the pointer since we have a must use after x).
…
// rc(x) >= 1
use(x)

Thus we know that statically the calls to A(x), B(x) can together only
release rc(x) N times. Thus if we remove the inner retain, release pair:

// rc(x) == N (for some N).
retain(x)
// rc(x) == N+1
call A(x)
call B(x)
// rc(x) >= 1
…
// rc(x) >= 1
use(x)

We are still safe unless in the final … there are unbalanced retains,
releases which would have caused the program to blow up anyways even
before optimization occurred. The simplest form of must use is an
additional release that has not been paired up with any retain (if we
had paired the release with a retain and removed it we would not have
the additional use). This fits nicely into the ARC framework since
basically what you do is say that given any nested releases regardless
of what is in between, the inner release is known safe. This enables us to get
back the lost performance.

<rdar://problem/19023795>

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232351 91177308-0d34-0410-b5e6-96231b3b80d8
2015-03-16 07:02:36 +00:00

3025 lines
85 KiB
LLVM
Raw Blame History

; RUN: opt -basicaa -objc-arc -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64"
declare i8* @objc_retain(i8*)
declare i8* @objc_retainAutoreleasedReturnValue(i8*)
declare void @objc_release(i8*)
declare i8* @objc_autorelease(i8*)
declare i8* @objc_autoreleaseReturnValue(i8*)
declare void @objc_autoreleasePoolPop(i8*)
declare i8* @objc_autoreleasePoolPush()
declare i8* @objc_retainBlock(i8*)
declare i8* @objc_retainedObject(i8*)
declare i8* @objc_unretainedObject(i8*)
declare i8* @objc_unretainedPointer(i8*)
declare void @use_pointer(i8*)
declare void @callee()
declare void @callee_fnptr(void ()*)
declare void @invokee()
declare i8* @returner()
declare void @bar(i32 ()*)
declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
declare i8* @objc_msgSend(i8*, i8*, ...)
; Simple retain+release pair deletion, with some intervening control
; flow and harmless instructions.
; CHECK: define void @test0_precise(i32* %x, i1 %p) [[NUW:#[0-9]+]] {
; CHECK: @objc_retain
; CHECK: @objc_release
; CHECK: }
define void @test0_precise(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
store i32 7, i32* %x
br label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
ret void
}
; CHECK: define void @test0_imprecise(i32* %x, i1 %p) [[NUW]] {
; CHECK-NOT: @objc_
; CHECK: }
define void @test0_imprecise(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
store i32 7, i32* %x
br label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
ret void
}
; Like test0 but the release isn't always executed when the retain is,
; so the optimization is not safe.
; TODO: Make the objc_release's argument be %0.
; CHECK: define void @test1_precise(i32* %x, i1 %p, i1 %q) [[NUW]] {
; CHECK: @objc_retain(i8* %a)
; CHECK: @objc_release
; CHECK: }
define void @test1_precise(i32* %x, i1 %p, i1 %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
store i32 7, i32* %x
call void @callee()
br i1 %q, label %return, label %alt_return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
ret void
alt_return:
ret void
}
; CHECK: define void @test1_imprecise(i32* %x, i1 %p, i1 %q) [[NUW]] {
; CHECK: @objc_retain(i8* %a)
; CHECK: @objc_release
; CHECK: }
define void @test1_imprecise(i32* %x, i1 %p, i1 %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
store i32 7, i32* %x
call void @callee()
br i1 %q, label %return, label %alt_return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
ret void
alt_return:
ret void
}
; Don't do partial elimination into two different CFG diamonds.
; CHECK: define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
; CHECK: entry:
; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK-NOT: @objc_
; CHECK: if.end5:
; CHECK: tail call void @objc_release(i8* %x) [[NUW]]
; CHECK-NOT: @objc_
; CHECK: }
define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
entry:
tail call i8* @objc_retain(i8* %x) nounwind
br i1 %p, label %if.then, label %if.end
if.then: ; preds = %entry
tail call void @callee()
br label %if.end
if.end: ; preds = %if.then, %entry
br i1 %q, label %if.then3, label %if.end5
if.then3: ; preds = %if.end
tail call void @use_pointer(i8* %x)
br label %if.end5
if.end5: ; preds = %if.then3, %if.end
tail call void @objc_release(i8* %x) nounwind
ret void
}
; CHECK-LABEL: define void @test1b_imprecise(
; CHECK: entry:
; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW:#[0-9]+]]
; CHECK-NOT: @objc_
; CHECK: if.end5:
; CHECK: tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE:[0-9]+]]
; CHECK-NOT: @objc_
; CHECK: }
define void @test1b_imprecise(i8* %x, i1 %p, i1 %q) {
entry:
tail call i8* @objc_retain(i8* %x) nounwind
br i1 %p, label %if.then, label %if.end
if.then: ; preds = %entry
tail call void @callee()
br label %if.end
if.end: ; preds = %if.then, %entry
br i1 %q, label %if.then3, label %if.end5
if.then3: ; preds = %if.end
tail call void @use_pointer(i8* %x)
br label %if.end5
if.end5: ; preds = %if.then3, %if.end
tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
ret void
}
; Like test0 but the pointer is passed to an intervening call,
; so the optimization is not safe.
; CHECK-LABEL: define void @test2_precise(
; CHECK: @objc_retain(i8* %a)
; CHECK: @objc_release
; CHECK: }
define void @test2_precise(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
store i32 7, i32* %x
call void @use_pointer(i8* %0)
%d = bitcast i32* %x to float*
store float 3.0, float* %d
br label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
ret void
}
; CHECK-LABEL: define void @test2_imprecise(
; CHECK: @objc_retain(i8* %a)
; CHECK: @objc_release
; CHECK: }
define void @test2_imprecise(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
store i32 7, i32* %x
call void @use_pointer(i8* %0)
%d = bitcast i32* %x to float*
store float 3.0, float* %d
br label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
ret void
}
; Like test0 but the release is in a loop,
; so the optimization is not safe.
; TODO: For now, assume this can't happen.
; CHECK-LABEL: define void @test3_precise(
; TODO: @objc_retain(i8* %a)
; TODO: @objc_release
; CHECK: }
define void @test3_precise(i32* %x, i1* %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br label %loop
loop:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
%j = load volatile i1, i1* %q
br i1 %j, label %loop, label %return
return:
ret void
}
; CHECK-LABEL: define void @test3_imprecise(
; TODO: @objc_retain(i8* %a)
; TODO: @objc_release
; CHECK: }
define void @test3_imprecise(i32* %x, i1* %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br label %loop
loop:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
%j = load volatile i1, i1* %q
br i1 %j, label %loop, label %return
return:
ret void
}
; TODO: For now, assume this can't happen.
; Like test0 but the retain is in a loop,
; so the optimization is not safe.
; CHECK-LABEL: define void @test4_precise(
; TODO: @objc_retain(i8* %a)
; TODO: @objc_release
; CHECK: }
define void @test4_precise(i32* %x, i1* %q) nounwind {
entry:
br label %loop
loop:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
%j = load volatile i1, i1* %q
br i1 %j, label %loop, label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
ret void
}
; CHECK-LABEL: define void @test4_imprecise(
; TODO: @objc_retain(i8* %a)
; TODO: @objc_release
; CHECK: }
define void @test4_imprecise(i32* %x, i1* %q) nounwind {
entry:
br label %loop
loop:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
%j = load volatile i1, i1* %q
br i1 %j, label %loop, label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
ret void
}
; Like test0 but the pointer is conditionally passed to an intervening call,
; so the optimization is not safe.
; CHECK-LABEL: define void @test5a(
; CHECK: @objc_retain(i8*
; CHECK: @objc_release
; CHECK: }
define void @test5a(i32* %x, i1 %q, i8* %y) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
%s = select i1 %q, i8* %y, i8* %0
call void @use_pointer(i8* %s)
store i32 7, i32* %x
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
ret void
}
; CHECK-LABEL: define void @test5b(
; CHECK: @objc_retain(i8*
; CHECK: @objc_release
; CHECK: }
define void @test5b(i32* %x, i1 %q, i8* %y) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
%s = select i1 %q, i8* %y, i8* %0
call void @use_pointer(i8* %s)
store i32 7, i32* %x
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
ret void
}
; retain+release pair deletion, where the release happens on two different
; flow paths.
; CHECK-LABEL: define void @test6a(
; CHECK: entry:
; CHECK: tail call i8* @objc_retain(
; CHECK: t:
; CHECK: call void @objc_release(
; CHECK: f:
; CHECK: call void @objc_release(
; CHECK: return:
; CHECK: }
define void @test6a(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
%ct = bitcast i32* %x to i8*
call void @objc_release(i8* %ct) nounwind
br label %return
f:
store i32 7, i32* %x
call void @callee()
%cf = bitcast i32* %x to i8*
call void @objc_release(i8* %cf) nounwind
br label %return
return:
ret void
}
; CHECK-LABEL: define void @test6b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test6b(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
%ct = bitcast i32* %x to i8*
call void @objc_release(i8* %ct) nounwind, !clang.imprecise_release !0
br label %return
f:
store i32 7, i32* %x
call void @callee()
%cf = bitcast i32* %x to i8*
call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
br label %return
return:
ret void
}
; CHECK-LABEL: define void @test6c(
; CHECK: entry:
; CHECK: tail call i8* @objc_retain(
; CHECK: t:
; CHECK: call void @objc_release(
; CHECK: f:
; CHECK: call void @objc_release(
; CHECK: return:
; CHECK: }
define void @test6c(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
%ct = bitcast i32* %x to i8*
call void @objc_release(i8* %ct) nounwind
br label %return
f:
store i32 7, i32* %x
call void @callee()
%cf = bitcast i32* %x to i8*
call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
br label %return
return:
ret void
}
; CHECK-LABEL: define void @test6d(
; CHECK: entry:
; CHECK: tail call i8* @objc_retain(
; CHECK: t:
; CHECK: call void @objc_release(
; CHECK: f:
; CHECK: call void @objc_release(
; CHECK: return:
; CHECK: }
define void @test6d(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
%0 = call i8* @objc_retain(i8* %a) nounwind
br i1 %p, label %t, label %f
t:
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
%ct = bitcast i32* %x to i8*
call void @objc_release(i8* %ct) nounwind, !clang.imprecise_release !0
br label %return
f:
store i32 7, i32* %x
call void @callee()
%cf = bitcast i32* %x to i8*
call void @objc_release(i8* %cf) nounwind
br label %return
return:
ret void
}
; retain+release pair deletion, where the retain happens on two different
; flow paths.
; CHECK-LABEL: define void @test7(
; CHECK: entry:
; CHECK-NOT: objc_
; CHECK: t:
; CHECK: call i8* @objc_retain
; CHECK: f:
; CHECK: call i8* @objc_retain
; CHECK: return:
; CHECK: call void @objc_release
; CHECK: }
define void @test7(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
br i1 %p, label %t, label %f
t:
%0 = call i8* @objc_retain(i8* %a) nounwind
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
%1 = call i8* @objc_retain(i8* %a) nounwind
store i32 7, i32* %x
call void @callee()
br label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
ret void
}
; CHECK-LABEL: define void @test7b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test7b(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
br i1 %p, label %t, label %f
t:
%0 = call i8* @objc_retain(i8* %a) nounwind
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
%1 = call i8* @objc_retain(i8* %a) nounwind
store i32 7, i32* %x
call void @callee()
br label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
ret void
}
; Like test7, but there's a retain/retainBlock mismatch. Don't delete!
; CHECK-LABEL: define void @test7c(
; CHECK: t:
; CHECK: call i8* @objc_retainBlock
; CHECK: f:
; CHECK: call i8* @objc_retain
; CHECK: return:
; CHECK: call void @objc_release
; CHECK: }
define void @test7c(i32* %x, i1 %p) nounwind {
entry:
%a = bitcast i32* %x to i8*
br i1 %p, label %t, label %f
t:
%0 = call i8* @objc_retainBlock(i8* %a) nounwind
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %return
f:
%1 = call i8* @objc_retain(i8* %a) nounwind
store i32 7, i32* %x
call void @callee()
br label %return
return:
%c = bitcast i32* %x to i8*
call void @objc_release(i8* %c) nounwind
ret void
}
; retain+release pair deletion, where the retain and release both happen on
; different flow paths. Wild!
; CHECK-LABEL: define void @test8a(
; CHECK: entry:
; CHECK: t:
; CHECK: @objc_retain
; CHECK: f:
; CHECK: @objc_retain
; CHECK: mid:
; CHECK: u:
; CHECK: @objc_release
; CHECK: g:
; CHECK: @objc_release
; CHECK: return:
; CHECK: }
define void @test8a(i32* %x, i1 %p, i1 %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
br i1 %p, label %t, label %f
t:
%0 = call i8* @objc_retain(i8* %a) nounwind
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %mid
f:
%1 = call i8* @objc_retain(i8* %a) nounwind
store i32 7, i32* %x
br label %mid
mid:
br i1 %q, label %u, label %g
u:
call void @callee()
%cu = bitcast i32* %x to i8*
call void @objc_release(i8* %cu) nounwind
br label %return
g:
%cg = bitcast i32* %x to i8*
call void @objc_release(i8* %cg) nounwind
br label %return
return:
ret void
}
; CHECK-LABEL: define void @test8b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test8b(i32* %x, i1 %p, i1 %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
br i1 %p, label %t, label %f
t:
%0 = call i8* @objc_retain(i8* %a) nounwind
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %mid
f:
%1 = call i8* @objc_retain(i8* %a) nounwind
store i32 7, i32* %x
br label %mid
mid:
br i1 %q, label %u, label %g
u:
call void @callee()
%cu = bitcast i32* %x to i8*
call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
br label %return
g:
%cg = bitcast i32* %x to i8*
call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
br label %return
return:
ret void
}
; CHECK-LABEL: define void @test8c(
; CHECK: entry:
; CHECK: t:
; CHECK: @objc_retain
; CHECK: f:
; CHECK: @objc_retain
; CHECK: mid:
; CHECK: u:
; CHECK: @objc_release
; CHECK: g:
; CHECK: @objc_release
; CHECK: return:
; CHECK: }
define void @test8c(i32* %x, i1 %p, i1 %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
br i1 %p, label %t, label %f
t:
%0 = call i8* @objc_retain(i8* %a) nounwind
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %mid
f:
%1 = call i8* @objc_retain(i8* %a) nounwind
store i32 7, i32* %x
br label %mid
mid:
br i1 %q, label %u, label %g
u:
call void @callee()
%cu = bitcast i32* %x to i8*
call void @objc_release(i8* %cu) nounwind
br label %return
g:
%cg = bitcast i32* %x to i8*
call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
br label %return
return:
ret void
}
; CHECK-LABEL: define void @test8d(
; CHECK: entry:
; CHECK: t:
; CHECK: @objc_retain
; CHECK: f:
; CHECK: @objc_retain
; CHECK: mid:
; CHECK: u:
; CHECK: @objc_release
; CHECK: g:
; CHECK: @objc_release
; CHECK: return:
; CHECK: }
define void @test8d(i32* %x, i1 %p, i1 %q) nounwind {
entry:
%a = bitcast i32* %x to i8*
br i1 %p, label %t, label %f
t:
%0 = call i8* @objc_retain(i8* %a) nounwind
store i8 3, i8* %a
%b = bitcast i32* %x to float*
store float 2.0, float* %b
br label %mid
f:
%1 = call i8* @objc_retain(i8* %a) nounwind
store i32 7, i32* %x
br label %mid
mid:
br i1 %q, label %u, label %g
u:
call void @callee()
%cu = bitcast i32* %x to i8*
call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
br label %return
g:
%cg = bitcast i32* %x to i8*
call void @objc_release(i8* %cg) nounwind
br label %return
return:
ret void
}
; Trivial retain+release pair deletion.
; CHECK-LABEL: define void @test9(
; CHECK-NOT: @objc_
; CHECK: }
define void @test9(i8* %x) nounwind {
entry:
%0 = call i8* @objc_retain(i8* %x) nounwind
call void @objc_release(i8* %0) nounwind
ret void
}
; Retain+release pair, but on an unknown pointer relationship. Don't delete!
; CHECK-LABEL: define void @test9b(
; CHECK: @objc_retain(i8* %x)
; CHECK: @objc_release(i8* %s)
; CHECK: }
define void @test9b(i8* %x, i1 %j, i8* %p) nounwind {
entry:
%0 = call i8* @objc_retain(i8* %x) nounwind
%s = select i1 %j, i8* %x, i8* %p
call void @objc_release(i8* %s) nounwind
ret void
}
; Trivial retain+release pair with intervening calls - don't delete!
; CHECK-LABEL: define void @test10(
; CHECK: @objc_retain(i8* %x)
; CHECK: @callee
; CHECK: @use_pointer
; CHECK: @objc_release
; CHECK: }
define void @test10(i8* %x) nounwind {
entry:
%0 = call i8* @objc_retain(i8* %x) nounwind
call void @callee()
call void @use_pointer(i8* %x)
call void @objc_release(i8* %0) nounwind
ret void
}
; Trivial retain+autoreleaserelease pair. Don't delete!
; Also, add a tail keyword, since objc_retain can never be passed
; a stack argument.
; CHECK-LABEL: define void @test11(
; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK: call i8* @objc_autorelease(i8* %0) [[NUW]]
; CHECK: }
define void @test11(i8* %x) nounwind {
entry:
%0 = call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_autorelease(i8* %0) nounwind
call void @use_pointer(i8* %x)
ret void
}
; Same as test11 but with no use_pointer call. Delete the pair!
; CHECK-LABEL: define void @test11a(
; CHECK: entry:
; CHECK-NEXT: ret void
; CHECK: }
define void @test11a(i8* %x) nounwind {
entry:
%0 = call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_autorelease(i8* %0) nounwind
ret void
}
; Same as test11 but the value is returned. Do not perform an RV optimization
; since if the frontend emitted code for an __autoreleasing variable, we may
; want it to be in the autorelease pool.
; CHECK-LABEL: define i8* @test11b(
; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK: call i8* @objc_autorelease(i8* %0) [[NUW]]
; CHECK: }
define i8* @test11b(i8* %x) nounwind {
entry:
%0 = call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_autorelease(i8* %0) nounwind
ret i8* %x
}
; We can not delete this retain, release since we do not have a post-dominating
; use of the release.
; CHECK-LABEL: define void @test12(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_retain(i8* %x)
; CHECK-NEXT: @objc_retain
; CHECK: @objc_release
; CHECK: }
define void @test12(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; Trivial retain,autorelease pair. Don't delete!
; CHECK-LABEL: define void @test13(
; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK: @use_pointer(i8* %x)
; CHECK: call i8* @objc_autorelease(i8* %x) [[NUW]]
; CHECK: }
define void @test13(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call i8* @objc_autorelease(i8* %x) nounwind
ret void
}
; Delete the retain+release pair.
; CHECK-LABEL: define void @test13b(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_retain(i8* %x)
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test13b(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; Don't delete the retain+release pair because there's an
; autoreleasePoolPop in the way.
; CHECK-LABEL: define void @test13c(
; CHECK: @objc_retain(i8* %x)
; CHECK: @objc_autoreleasePoolPop
; CHECK: @objc_retain(i8* %x)
; CHECK: @use_pointer
; CHECK: @objc_release
; CHECK: }
define void @test13c(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call void @objc_autoreleasePoolPop(i8* undef)
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; Like test13c, but there's an autoreleasePoolPush in the way, but that
; doesn't matter.
; CHECK-LABEL: define void @test13d(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_retain(i8* %x)
; CHECK-NEXT: @objc_autoreleasePoolPush
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test13d(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_autoreleasePoolPush()
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; Trivial retain,release pair with intervening call, and it's post-dominated by
; another release. But it is not known safe in the top down direction. We can
; not eliminate it.
; CHECK-LABEL: define void @test14(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_retain
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @objc_release
; CHECK-NEXT: @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test14(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind
ret void
}
; Trivial retain,autorelease pair with intervening call, but it's post-dominated
; by another release. Don't delete anything.
; CHECK-LABEL: define void @test15(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_retain(i8* %x)
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @objc_autorelease(i8* %x)
; CHECK-NEXT: @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test15(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call i8* @objc_autorelease(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind
ret void
}
; Trivial retain,autorelease pair, post-dominated
; by another release. Delete the retain and release.
; CHECK-LABEL: define void @test15b(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_retain
; CHECK-NEXT: @objc_autorelease
; CHECK-NEXT: @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test15b(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_autorelease(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind
ret void
}
; CHECK-LABEL: define void @test15c(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_autorelease
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test15c(i8* %x, i64 %n) {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_autorelease(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
ret void
}
; Retain+release pairs in diamonds, all dominated by a retain.
; CHECK-LABEL: define void @test16a(
; CHECK: @objc_retain(i8* %x)
; CHECK-NOT: @objc
; CHECK: purple:
; CHECK: @use_pointer
; CHECK: @objc_release
; CHECK: }
define void @test16a(i1 %a, i1 %b, i8* %x) {
entry:
call i8* @objc_retain(i8* %x) nounwind
br i1 %a, label %red, label %orange
red:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
orange:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
yellow:
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
br i1 %b, label %green, label %blue
green:
call void @objc_release(i8* %x) nounwind
br label %purple
blue:
call void @objc_release(i8* %x) nounwind
br label %purple
purple:
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; CHECK-LABEL: define void @test16b(
; CHECK: @objc_retain(i8* %x)
; CHECK-NOT: @objc
; CHECK: purple:
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @use_pointer
; CHECK-NEXT: @objc_release
; CHECK: }
define void @test16b(i1 %a, i1 %b, i8* %x) {
entry:
call i8* @objc_retain(i8* %x) nounwind
br i1 %a, label %red, label %orange
red:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
orange:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
yellow:
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
br i1 %b, label %green, label %blue
green:
call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
br label %purple
blue:
call void @objc_release(i8* %x) nounwind
br label %purple
purple:
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; CHECK-LABEL: define void @test16c(
; CHECK: @objc_retain(i8* %x)
; CHECK-NOT: @objc
; CHECK: purple:
; CHECK: @use_pointer
; CHECK: @objc_release
; CHECK: }
define void @test16c(i1 %a, i1 %b, i8* %x) {
entry:
call i8* @objc_retain(i8* %x) nounwind
br i1 %a, label %red, label %orange
red:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
orange:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
yellow:
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
br i1 %b, label %green, label %blue
green:
call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
br label %purple
blue:
call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
br label %purple
purple:
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
ret void
}
; CHECK-LABEL: define void @test16d(
; CHECK: @objc_retain(i8* %x)
; CHECK: @objc
; CHECK: }
define void @test16d(i1 %a, i1 %b, i8* %x) {
entry:
call i8* @objc_retain(i8* %x) nounwind
br i1 %a, label %red, label %orange
red:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
orange:
call i8* @objc_retain(i8* %x) nounwind
br label %yellow
yellow:
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
br i1 %b, label %green, label %blue
green:
call void @objc_release(i8* %x) nounwind
br label %purple
blue:
call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
br label %purple
purple:
ret void
}
; Delete no-ops.
; CHECK-LABEL: define void @test18(
; CHECK-NOT: @objc_
; CHECK: }
define void @test18() {
call i8* @objc_retain(i8* null)
call void @objc_release(i8* null)
call i8* @objc_autorelease(i8* null)
ret void
}
; Delete no-ops where undef can be assumed to be null.
; CHECK-LABEL: define void @test18b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test18b() {
call i8* @objc_retain(i8* undef)
call void @objc_release(i8* undef)
call i8* @objc_autorelease(i8* undef)
ret void
}
; Replace uses of arguments with uses of return values, to reduce
; register pressure.
; CHECK: define void @test19(i32* %y) {
; CHECK: %z = bitcast i32* %y to i8*
; CHECK: %0 = bitcast i32* %y to i8*
; CHECK: %1 = tail call i8* @objc_retain(i8* %0)
; CHECK: call void @use_pointer(i8* %z)
; CHECK: call void @use_pointer(i8* %z)
; CHECK: %2 = bitcast i32* %y to i8*
; CHECK: call void @objc_release(i8* %2)
; CHECK: ret void
; CHECK: }
define void @test19(i32* %y) {
entry:
%x = bitcast i32* %y to i8*
%0 = call i8* @objc_retain(i8* %x) nounwind
%z = bitcast i32* %y to i8*
call void @use_pointer(i8* %z)
call void @use_pointer(i8* %z)
call void @objc_release(i8* %x)
ret void
}
; Bitcast insertion
; CHECK-LABEL: define void @test20(
; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) [[NUW]]
; CHECK-NEXT: invoke
; CHECK: }
define void @test20(double* %self) {
if.then12:
%tmp = bitcast double* %self to i8*
%tmp1 = call i8* @objc_retain(i8* %tmp) nounwind
invoke void @invokee()
to label %invoke.cont23 unwind label %lpad20
invoke.cont23: ; preds = %if.then12
invoke void @invokee()
to label %if.end unwind label %lpad20
lpad20: ; preds = %invoke.cont23, %if.then12
%tmp502 = phi double* [ undef, %invoke.cont23 ], [ %self, %if.then12 ]
%exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
cleanup
unreachable
if.end: ; preds = %invoke.cont23
ret void
}
; Delete a redundant retain,autorelease when forwaring a call result
; directly to a return value.
; CHECK-LABEL: define i8* @test21(
; CHECK: call i8* @returner()
; CHECK-NEXT: ret i8* %call
; CHECK-NEXT: }
define i8* @test21() {
entry:
%call = call i8* @returner()
%0 = call i8* @objc_retain(i8* %call) nounwind
%1 = call i8* @objc_autorelease(i8* %0) nounwind
ret i8* %1
}
; Move an objc call up through a phi that has null operands.
; CHECK-LABEL: define void @test22(
; CHECK: B:
; CHECK: %1 = bitcast double* %p to i8*
; CHECK: call void @objc_release(i8* %1)
; CHECK: br label %C
; CHECK: C: ; preds = %B, %A
; CHECK-NOT: @objc_release
; CHECK: }
define void @test22(double* %p, i1 %a) {
br i1 %a, label %A, label %B
A:
br label %C
B:
br label %C
C:
%h = phi double* [ null, %A ], [ %p, %B ]
%c = bitcast double* %h to i8*
call void @objc_release(i8* %c)
ret void
}
; Any call can decrement a retain count.
; CHECK-LABEL: define void @test24(
; CHECK: @objc_retain(i8* %a)
; CHECK: @objc_release
; CHECK: }
define void @test24(i8* %r, i8* %a) {
call i8* @objc_retain(i8* %a)
call void @use_pointer(i8* %r)
%q = load i8, i8* %a
call void @objc_release(i8* %a)
ret void
}
; Don't move a retain/release pair if the release can be moved
; but the retain can't be moved to balance it.
; CHECK-LABEL: define void @test25(
; CHECK: entry:
; CHECK: call i8* @objc_retain(i8* %p)
; CHECK: true:
; CHECK: done:
; CHECK: call void @objc_release(i8* %p)
; CHECK: }
define void @test25(i8* %p, i1 %x) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
call void @callee()
br i1 %x, label %true, label %done
true:
store i8 0, i8* %p
br label %done
done:
call void @objc_release(i8* %p)
ret void
}
; Don't move a retain/release pair if the retain can be moved
; but the release can't be moved to balance it.
; CHECK-LABEL: define void @test26(
; CHECK: entry:
; CHECK: call i8* @objc_retain(i8* %p)
; CHECK: true:
; CHECK: done:
; CHECK: call void @objc_release(i8* %p)
; CHECK: }
define void @test26(i8* %p, i1 %x) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
br label %done
done:
store i8 0, i8* %p
call void @objc_release(i8* %p)
ret void
}
; Don't sink the retain,release into the loop.
; CHECK-LABEL: define void @test27(
; CHECK: entry:
; CHECK: call i8* @objc_retain(i8* %p)
; CHECK: loop:
; CHECK-NOT: @objc_
; CHECK: done:
; CHECK: call void @objc_release
; CHECK: }
define void @test27(i8* %p, i1 %x, i1 %y) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %loop, label %done
loop:
call void @callee()
store i8 0, i8* %p
br i1 %y, label %done, label %loop
done:
call void @objc_release(i8* %p)
ret void
}
; Trivial code motion case: Triangle.
; CHECK-LABEL: define void @test28(
; CHECK-NOT: @objc_
; CHECK: true:
; CHECK: call i8* @objc_retain(
; CHECK: call void @callee()
; CHECK: store
; CHECK: call void @objc_release
; CHECK: done:
; CHECK-NOT: @objc_
; CHECK: }
define void @test28(i8* %p, i1 %x) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
store i8 0, i8* %p
br label %done
done:
call void @objc_release(i8* %p), !clang.imprecise_release !0
ret void
}
; Trivial code motion case: Triangle, but no metadata. Don't move past
; unrelated memory references!
; CHECK-LABEL: define void @test28b(
; CHECK: call i8* @objc_retain(
; CHECK: true:
; CHECK-NOT: @objc_
; CHECK: call void @callee()
; CHECK-NOT: @objc_
; CHECK: store
; CHECK-NOT: @objc_
; CHECK: done:
; CHECK: @objc_release
; CHECK: }
define void @test28b(i8* %p, i1 %x, i8* noalias %t) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
store i8 0, i8* %p
br label %done
done:
store i8 0, i8* %t
call void @objc_release(i8* %p)
ret void
}
; Trivial code motion case: Triangle, with metadata. Do move past
; unrelated memory references! And preserve the metadata.
; CHECK-LABEL: define void @test28c(
; CHECK-NOT: @objc_
; CHECK: true:
; CHECK: call i8* @objc_retain(
; CHECK: call void @callee()
; CHECK: store
; CHECK: call void @objc_release(i8* %p) [[NUW]], !clang.imprecise_release
; CHECK: done:
; CHECK-NOT: @objc_
; CHECK: }
define void @test28c(i8* %p, i1 %x, i8* noalias %t) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
store i8 0, i8* %p
br label %done
done:
store i8 0, i8* %t
call void @objc_release(i8* %p), !clang.imprecise_release !0
ret void
}
; Like test28. but with two releases.
; CHECK-LABEL: define void @test29(
; CHECK-NOT: @objc_
; CHECK: true:
; CHECK: call i8* @objc_retain(
; CHECK: call void @callee()
; CHECK: store
; CHECK: call void @objc_release
; CHECK-NOT: @objc_release
; CHECK: done:
; CHECK-NOT: @objc_
; CHECK: ohno:
; CHECK-NOT: @objc_
; CHECK: }
define void @test29(i8* %p, i1 %x, i1 %y) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
store i8 0, i8* %p
br i1 %y, label %done, label %ohno
done:
call void @objc_release(i8* %p)
ret void
ohno:
call void @objc_release(i8* %p)
ret void
}
; Basic case with the use and call in a diamond
; with an extra release.
; CHECK-LABEL: define void @test30(
; CHECK-NOT: @objc_
; CHECK: true:
; CHECK: call i8* @objc_retain(
; CHECK: call void @callee()
; CHECK: store
; CHECK: call void @objc_release
; CHECK-NOT: @objc_release
; CHECK: false:
; CHECK-NOT: @objc_
; CHECK: done:
; CHECK-NOT: @objc_
; CHECK: ohno:
; CHECK-NOT: @objc_
; CHECK: }
define void @test30(i8* %p, i1 %x, i1 %y, i1 %z) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %false
true:
call void @callee()
store i8 0, i8* %p
br i1 %y, label %done, label %ohno
false:
br i1 %z, label %done, label %ohno
done:
call void @objc_release(i8* %p)
ret void
ohno:
call void @objc_release(i8* %p)
ret void
}
; Basic case with a mergeable release.
; CHECK-LABEL: define void @test31(
; CHECK: call i8* @objc_retain(i8* %p)
; CHECK: call void @callee()
; CHECK: store
; CHECK: call void @objc_release
; CHECK-NOT: @objc_release
; CHECK: true:
; CHECK-NOT: @objc_release
; CHECK: false:
; CHECK-NOT: @objc_release
; CHECK: ret void
; CHECK-NOT: @objc_release
; CHECK: }
define void @test31(i8* %p, i1 %x) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
call void @callee()
store i8 0, i8* %p
br i1 %x, label %true, label %false
true:
call void @objc_release(i8* %p)
ret void
false:
call void @objc_release(i8* %p)
ret void
}
; Don't consider bitcasts or getelementptrs direct uses.
; CHECK-LABEL: define void @test32(
; CHECK-NOT: @objc_
; CHECK: true:
; CHECK: call i8* @objc_retain(
; CHECK: call void @callee()
; CHECK: store
; CHECK: call void @objc_release
; CHECK: done:
; CHECK-NOT: @objc_
; CHECK: }
define void @test32(i8* %p, i1 %x) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
store i8 0, i8* %p
br label %done
done:
%g = bitcast i8* %p to i8*
%h = getelementptr i8, i8* %g, i64 0
call void @objc_release(i8* %g)
ret void
}
; Do consider icmps to be direct uses.
; CHECK-LABEL: define void @test33(
; CHECK-NOT: @objc_
; CHECK: true:
; CHECK: call i8* @objc_retain(
; CHECK: call void @callee()
; CHECK: icmp
; CHECK: call void @objc_release
; CHECK: done:
; CHECK-NOT: @objc_
; CHECK: }
define void @test33(i8* %p, i1 %x, i8* %y) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
%v = icmp eq i8* %p, %y
br label %done
done:
%g = bitcast i8* %p to i8*
%h = getelementptr i8, i8* %g, i64 0
call void @objc_release(i8* %g)
ret void
}
; Delete retain,release if there's just a possible dec and we have imprecise
; releases.
; CHECK-LABEL: define void @test34a(
; CHECK: call i8* @objc_retain
; CHECK: true:
; CHECK: done:
; CHECK: call void @objc_release
; CHECK: }
define void @test34a(i8* %p, i1 %x, i8* %y) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
br label %done
done:
%g = bitcast i8* %p to i8*
%h = getelementptr i8, i8* %g, i64 0
call void @objc_release(i8* %g)
ret void
}
; CHECK-LABEL: define void @test34b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test34b(i8* %p, i1 %x, i8* %y) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
call void @callee()
br label %done
done:
%g = bitcast i8* %p to i8*
%h = getelementptr i8, i8* %g, i64 0
call void @objc_release(i8* %g), !clang.imprecise_release !0
ret void
}
; Delete retain,release if there's just a use and we do not have a precise
; release.
; Precise.
; CHECK-LABEL: define void @test35a(
; CHECK: entry:
; CHECK: call i8* @objc_retain
; CHECK: true:
; CHECK: done:
; CHECK: call void @objc_release
; CHECK: }
define void @test35a(i8* %p, i1 %x, i8* %y) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
%v = icmp eq i8* %p, %y
br label %done
done:
%g = bitcast i8* %p to i8*
%h = getelementptr i8, i8* %g, i64 0
call void @objc_release(i8* %g)
ret void
}
; Imprecise.
; CHECK-LABEL: define void @test35b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test35b(i8* %p, i1 %x, i8* %y) {
entry:
%f0 = call i8* @objc_retain(i8* %p)
br i1 %x, label %true, label %done
true:
%v = icmp eq i8* %p, %y
br label %done
done:
%g = bitcast i8* %p to i8*
%h = getelementptr i8, i8* %g, i64 0
call void @objc_release(i8* %g), !clang.imprecise_release !0
ret void
}
; Delete a retain,release if there's no actual use and we have precise release.
; CHECK-LABEL: define void @test36a(
; CHECK: @objc_retain
; CHECK: call void @callee()
; CHECK-NOT: @objc_
; CHECK: call void @callee()
; CHECK: @objc_release
; CHECK: }
define void @test36a(i8* %p) {
entry:
call i8* @objc_retain(i8* %p)
call void @callee()
call void @callee()
call void @objc_release(i8* %p)
ret void
}
; Like test36, but with metadata.
; CHECK-LABEL: define void @test36b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test36b(i8* %p) {
entry:
call i8* @objc_retain(i8* %p)
call void @callee()
call void @callee()
call void @objc_release(i8* %p), !clang.imprecise_release !0
ret void
}
; Be aggressive about analyzing phis to eliminate possible uses.
; CHECK-LABEL: define void @test38(
; CHECK-NOT: @objc_
; CHECK: }
define void @test38(i8* %p, i1 %u, i1 %m, i8* %z, i8* %y, i8* %x, i8* %w) {
entry:
call i8* @objc_retain(i8* %p)
br i1 %u, label %true, label %false
true:
br i1 %m, label %a, label %b
false:
br i1 %m, label %c, label %d
a:
br label %e
b:
br label %e
c:
br label %f
d:
br label %f
e:
%j = phi i8* [ %z, %a ], [ %y, %b ]
br label %g
f:
%k = phi i8* [ %w, %c ], [ %x, %d ]
br label %g
g:
%h = phi i8* [ %j, %e ], [ %k, %f ]
call void @use_pointer(i8* %h)
call void @objc_release(i8* %p), !clang.imprecise_release !0
ret void
}
; Delete retain,release pairs around loops.
; CHECK-LABEL: define void @test39(
; CHECK-NOT: @objc_
; CHECK: }
define void @test39(i8* %p) {
entry:
%0 = call i8* @objc_retain(i8* %p)
br label %loop
loop: ; preds = %loop, %entry
br i1 undef, label %loop, label %exit
exit: ; preds = %loop
call void @objc_release(i8* %0), !clang.imprecise_release !0
ret void
}
; Delete retain,release pairs around loops containing uses.
; CHECK-LABEL: define void @test39b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test39b(i8* %p) {
entry:
%0 = call i8* @objc_retain(i8* %p)
br label %loop
loop: ; preds = %loop, %entry
store i8 0, i8* %0
br i1 undef, label %loop, label %exit
exit: ; preds = %loop
call void @objc_release(i8* %0), !clang.imprecise_release !0
ret void
}
; Delete retain,release pairs around loops containing potential decrements.
; CHECK-LABEL: define void @test39c(
; CHECK-NOT: @objc_
; CHECK: }
define void @test39c(i8* %p) {
entry:
%0 = call i8* @objc_retain(i8* %p)
br label %loop
loop: ; preds = %loop, %entry
call void @use_pointer(i8* %0)
br i1 undef, label %loop, label %exit
exit: ; preds = %loop
call void @objc_release(i8* %0), !clang.imprecise_release !0
ret void
}
; Delete retain,release pairs around loops even if
; the successors are in a different order.
; CHECK-LABEL: define void @test40(
; CHECK-NOT: @objc_
; CHECK: }
define void @test40(i8* %p) {
entry:
%0 = call i8* @objc_retain(i8* %p)
br label %loop
loop: ; preds = %loop, %entry
call void @use_pointer(i8* %0)
br i1 undef, label %exit, label %loop
exit: ; preds = %loop
call void @objc_release(i8* %0), !clang.imprecise_release !0
ret void
}
; Do the known-incremented retain+release elimination even if the pointer
; is also autoreleased.
; CHECK-LABEL: define void @test42(
; CHECK-NEXT: entry:
; CHECK-NEXT: call i8* @objc_retain(i8* %p)
; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @objc_release(i8* %p)
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test42(i8* %p) {
entry:
call i8* @objc_retain(i8* %p)
call i8* @objc_autorelease(i8* %p)
call i8* @objc_retain(i8* %p)
call void @use_pointer(i8* %p)
call void @use_pointer(i8* %p)
call void @objc_release(i8* %p)
call void @use_pointer(i8* %p)
call void @use_pointer(i8* %p)
call void @objc_release(i8* %p)
ret void
}
; Don't the known-incremented retain+release elimination if the pointer is
; autoreleased and there's an autoreleasePoolPop.
; CHECK-LABEL: define void @test43(
; CHECK-NEXT: entry:
; CHECK-NEXT: call i8* @objc_retain(i8* %p)
; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
; CHECK-NEXT: call i8* @objc_retain
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @objc_autoreleasePoolPop(i8* undef)
; CHECK-NEXT: call void @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test43(i8* %p) {
entry:
call i8* @objc_retain(i8* %p)
call i8* @objc_autorelease(i8* %p)
call i8* @objc_retain(i8* %p)
call void @use_pointer(i8* %p)
call void @use_pointer(i8* %p)
call void @objc_autoreleasePoolPop(i8* undef)
call void @objc_release(i8* %p)
ret void
}
; Do the known-incremented retain+release elimination if the pointer is
; autoreleased and there's an autoreleasePoolPush.
; CHECK-LABEL: define void @test43b(
; CHECK-NEXT: entry:
; CHECK-NEXT: call i8* @objc_retain(i8* %p)
; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call i8* @objc_autoreleasePoolPush()
; CHECK-NEXT: call void @use_pointer(i8* %p)
; CHECK-NEXT: call void @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test43b(i8* %p) {
entry:
call i8* @objc_retain(i8* %p)
call i8* @objc_autorelease(i8* %p)
call i8* @objc_retain(i8* %p)
call void @use_pointer(i8* %p)
call void @use_pointer(i8* %p)
call i8* @objc_autoreleasePoolPush()
call void @objc_release(i8* %p)
call void @use_pointer(i8* %p)
call void @objc_release(i8* %p)
ret void
}
; Do retain+release elimination for non-provenance pointers.
; CHECK-LABEL: define void @test44(
; CHECK-NOT: objc_
; CHECK: }
define void @test44(i8** %pp) {
%p = load i8*, i8** %pp
%q = call i8* @objc_retain(i8* %p)
call void @objc_release(i8* %q)
ret void
}
; Don't delete retain+release with an unknown-provenance
; may-alias objc_release between them.
; CHECK-LABEL: define void @test45(
; CHECK: call i8* @objc_retain(i8* %p)
; CHECK: call void @objc_release(i8* %q)
; CHECK: call void @use_pointer(i8* %p)
; CHECK: call void @objc_release(i8* %p)
; CHECK: }
define void @test45(i8** %pp, i8** %qq) {
%p = load i8*, i8** %pp
%q = load i8*, i8** %qq
call i8* @objc_retain(i8* %p)
call void @objc_release(i8* %q)
call void @use_pointer(i8* %p)
call void @objc_release(i8* %p)
ret void
}
; Don't delete retain and autorelease here.
; CHECK-LABEL: define void @test46(
; CHECK: tail call i8* @objc_retain(i8* %p) [[NUW]]
; CHECK: true:
; CHECK: call i8* @objc_autorelease(i8* %p) [[NUW]]
; CHECK: }
define void @test46(i8* %p, i1 %a) {
entry:
call i8* @objc_retain(i8* %p)
br i1 %a, label %true, label %false
true:
call i8* @objc_autorelease(i8* %p)
call void @use_pointer(i8* %p)
ret void
false:
ret void
}
; Delete no-op cast calls.
; CHECK-LABEL: define i8* @test47(
; CHECK-NOT: call
; CHECK: ret i8* %p
; CHECK: }
define i8* @test47(i8* %p) nounwind {
%x = call i8* @objc_retainedObject(i8* %p)
ret i8* %x
}
; Delete no-op cast calls.
; CHECK-LABEL: define i8* @test48(
; CHECK-NOT: call
; CHECK: ret i8* %p
; CHECK: }
define i8* @test48(i8* %p) nounwind {
%x = call i8* @objc_unretainedObject(i8* %p)
ret i8* %x
}
; Delete no-op cast calls.
; CHECK-LABEL: define i8* @test49(
; CHECK-NOT: call
; CHECK: ret i8* %p
; CHECK: }
define i8* @test49(i8* %p) nounwind {
%x = call i8* @objc_unretainedPointer(i8* %p)
ret i8* %x
}
; Do delete retain+release with intervening stores of the address value if we
; have imprecise release attached to objc_release.
; CHECK-LABEL: define void @test50a(
; CHECK-NEXT: call i8* @objc_retain
; CHECK-NEXT: call void @callee
; CHECK-NEXT: store
; CHECK-NEXT: call void @objc_release
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test50a(i8* %p, i8** %pp) {
call i8* @objc_retain(i8* %p)
call void @callee()
store i8* %p, i8** %pp
call void @objc_release(i8* %p)
ret void
}
; CHECK-LABEL: define void @test50b(
; CHECK-NOT: @objc_
; CHECK: }
define void @test50b(i8* %p, i8** %pp) {
call i8* @objc_retain(i8* %p)
call void @callee()
store i8* %p, i8** %pp
call void @objc_release(i8* %p), !clang.imprecise_release !0
ret void
}
; Don't delete retain+release with intervening stores through the
; address value.
; CHECK-LABEL: define void @test51a(
; CHECK: call i8* @objc_retain(i8* %p)
; CHECK: call void @objc_release(i8* %p)
; CHECK: ret void
; CHECK: }
define void @test51a(i8* %p) {
call i8* @objc_retain(i8* %p)
call void @callee()
store i8 0, i8* %p
call void @objc_release(i8* %p)
ret void
}
; CHECK-LABEL: define void @test51b(
; CHECK: call i8* @objc_retain(i8* %p)
; CHECK: call void @objc_release(i8* %p)
; CHECK: ret void
; CHECK: }
define void @test51b(i8* %p) {
call i8* @objc_retain(i8* %p)
call void @callee()
store i8 0, i8* %p
call void @objc_release(i8* %p), !clang.imprecise_release !0
ret void
}
; Don't delete retain+release with intervening use of a pointer of
; unknown provenance.
; CHECK-LABEL: define void @test52a(
; CHECK: call i8* @objc_retain
; CHECK: call void @callee()
; CHECK: call void @use_pointer(i8* %z)
; CHECK: call void @objc_release
; CHECK: ret void
; CHECK: }
define void @test52a(i8** %zz, i8** %pp) {
%p = load i8*, i8** %pp
%1 = call i8* @objc_retain(i8* %p)
call void @callee()
%z = load i8*, i8** %zz
call void @use_pointer(i8* %z)
call void @objc_release(i8* %p)
ret void
}
; CHECK-LABEL: define void @test52b(
; CHECK: call i8* @objc_retain
; CHECK: call void @callee()
; CHECK: call void @use_pointer(i8* %z)
; CHECK: call void @objc_release
; CHECK: ret void
; CHECK: }
define void @test52b(i8** %zz, i8** %pp) {
%p = load i8*, i8** %pp
%1 = call i8* @objc_retain(i8* %p)
call void @callee()
%z = load i8*, i8** %zz
call void @use_pointer(i8* %z)
call void @objc_release(i8* %p), !clang.imprecise_release !0
ret void
}
; Like test52, but the pointer has function type, so it's assumed to
; be not reference counted.
; Oops. That's wrong. Clang sometimes uses function types gratuitously.
; See rdar://10551239.
; CHECK-LABEL: define void @test53(
; CHECK: @objc_
; CHECK: }
define void @test53(void ()** %zz, i8** %pp) {
%p = load i8*, i8** %pp
%1 = call i8* @objc_retain(i8* %p)
call void @callee()
%z = load void ()*, void ()** %zz
call void @callee_fnptr(void ()* %z)
call void @objc_release(i8* %p)
ret void
}
; Convert autorelease to release if the value is unused.
; CHECK-LABEL: define void @test54(
; CHECK: call i8* @returner()
; CHECK-NEXT: call void @objc_release(i8* %t) [[NUW]], !clang.imprecise_release ![[RELEASE]]
; CHECK-NEXT: ret void
; CHECK: }
define void @test54() {
%t = call i8* @returner()
call i8* @objc_autorelease(i8* %t)
ret void
}
; Nested retain+release pairs. Delete them both.
; CHECK-LABEL: define void @test55(
; CHECK-NOT: @objc
; CHECK: }
define void @test55(i8* %x) {
entry:
%0 = call i8* @objc_retain(i8* %x) nounwind
%1 = call i8* @objc_retain(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind
ret void
}
; Nested retain+release pairs where the inner pair depends
; on the outer pair to be removed, and then the outer pair
; can be partially eliminated. Plus an extra outer pair to
; eliminate, for fun.
; CHECK-LABEL: define void @test56(
; CHECK-NOT: @objc
; CHECK: if.then:
; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK-NEXT: tail call void @use_pointer(i8* %x)
; CHECK-NEXT: tail call void @use_pointer(i8* %x)
; CHECK-NEXT: tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE]]
; CHECK-NEXT: br label %if.end
; CHECK-NOT: @objc
; CHECK: }
define void @test56(i8* %x, i32 %n) {
entry:
%0 = tail call i8* @objc_retain(i8* %x) nounwind
%1 = tail call i8* @objc_retain(i8* %0) nounwind
%tobool = icmp eq i32 %n, 0
br i1 %tobool, label %if.end, label %if.then
if.then: ; preds = %entry
%2 = tail call i8* @objc_retain(i8* %1) nounwind
tail call void @use_pointer(i8* %2)
tail call void @use_pointer(i8* %2)
tail call void @objc_release(i8* %2) nounwind, !clang.imprecise_release !0
br label %if.end
if.end: ; preds = %entry, %if.then
tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
tail call void @objc_release(i8* %0) nounwind, !clang.imprecise_release !0
ret void
}
; When there are adjacent retain+release pairs, the first one is known
; unnecessary because the presence of the second one means that the first one
; won't be deleting the object.
; CHECK-LABEL: define void @test57(
; CHECK-NEXT: entry:
; CHECK-NEXT: tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: call void @objc_release(i8* %x) [[NUW]]
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test57(i8* %x) nounwind {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; An adjacent retain+release pair is sufficient even if it will be
; removed itself.
; CHECK-LABEL: define void @test58(
; CHECK-NEXT: entry:
; CHECK-NEXT: @objc_retain
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test58(i8* %x) nounwind {
entry:
call i8* @objc_retain(i8* %x) nounwind
call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
call i8* @objc_retain(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind
ret void
}
; Don't delete the second retain+release pair in an adjacent set.
; CHECK-LABEL: define void @test59(
; CHECK-NEXT: entry:
; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: call void @use_pointer(i8* %x)
; CHECK-NEXT: call void @objc_release(i8* %x) [[NUW]]
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test59(i8* %x) nounwind {
entry:
%a = call i8* @objc_retain(i8* %x) nounwind
call void @objc_release(i8* %x) nounwind
%b = call i8* @objc_retain(i8* %x) nounwind
call void @use_pointer(i8* %x)
call void @use_pointer(i8* %x)
call void @objc_release(i8* %x) nounwind
ret void
}
; Constant pointers to objects don't need reference counting.
@constptr = external constant i8*
@something = external global i8*
; We have a precise lifetime retain/release here. We can not remove them since
; @something is not constant.
; CHECK-LABEL: define void @test60a(
; CHECK: call i8* @objc_retain
; CHECK: call void @objc_release
; CHECK: }
define void @test60a() {
%t = load i8*, i8** @constptr
%s = load i8*, i8** @something
call i8* @objc_retain(i8* %s)
call void @callee()
call void @use_pointer(i8* %t)
call void @objc_release(i8* %s)
ret void
}
; CHECK-LABEL: define void @test60b(
; CHECK: call i8* @objc_retain
; CHECK-NOT: call i8* @objc_retain
; CHECK-NOT: call i8* @objc_release
; CHECK: }
define void @test60b() {
%t = load i8*, i8** @constptr
%s = load i8*, i8** @something
call i8* @objc_retain(i8* %t)
call i8* @objc_retain(i8* %t)
call void @callee()
call void @use_pointer(i8* %s)
call void @objc_release(i8* %t)
ret void
}
; CHECK-LABEL: define void @test60c(
; CHECK-NOT: @objc_
; CHECK: }
define void @test60c() {
%t = load i8*, i8** @constptr
%s = load i8*, i8** @something
call i8* @objc_retain(i8* %t)
call void @callee()
call void @use_pointer(i8* %s)
call void @objc_release(i8* %t), !clang.imprecise_release !0
ret void
}
; CHECK-LABEL: define void @test60d(
; CHECK-NOT: @objc_
; CHECK: }
define void @test60d() {
%t = load i8*, i8** @constptr
%s = load i8*, i8** @something
call i8* @objc_retain(i8* %t)
call void @callee()
call void @use_pointer(i8* %s)
call void @objc_release(i8* %t)
ret void
}
; CHECK-LABEL: define void @test60e(
; CHECK-NOT: @objc_
; CHECK: }
define void @test60e() {
%t = load i8*, i8** @constptr
%s = load i8*, i8** @something
call i8* @objc_retain(i8* %t)
call void @callee()
call void @use_pointer(i8* %s)
call void @objc_release(i8* %t), !clang.imprecise_release !0
ret void
}
; Constant pointers to objects don't need to be considered related to other
; pointers.
; CHECK-LABEL: define void @test61(
; CHECK-NOT: @objc_
; CHECK: }
define void @test61() {
%t = load i8*, i8** @constptr
call i8* @objc_retain(i8* %t)
call void @callee()
call void @use_pointer(i8* %t)
call void @objc_release(i8* %t)
ret void
}
; Delete a retain matched by releases when one is inside the loop and the
; other is outside the loop.
; CHECK-LABEL: define void @test62(
; CHECK-NOT: @objc_
; CHECK: }
define void @test62(i8* %x, i1* %p) nounwind {
entry:
br label %loop
loop:
call i8* @objc_retain(i8* %x)
%q = load i1, i1* %p
br i1 %q, label %loop.more, label %exit
loop.more:
call void @objc_release(i8* %x)
br label %loop
exit:
call void @objc_release(i8* %x)
ret void
}
; Like test62 but with no release in exit.
; Don't delete anything!
; CHECK-LABEL: define void @test63(
; CHECK: loop:
; CHECK: tail call i8* @objc_retain(i8* %x)
; CHECK: loop.more:
; CHECK: call void @objc_release(i8* %x)
; CHECK: }
define void @test63(i8* %x, i1* %p) nounwind {
entry:
br label %loop
loop:
call i8* @objc_retain(i8* %x)
%q = load i1, i1* %p
br i1 %q, label %loop.more, label %exit
loop.more:
call void @objc_release(i8* %x)
br label %loop
exit:
ret void
}
; Like test62 but with no release in loop.more.
; Don't delete anything!
; CHECK-LABEL: define void @test64(
; CHECK: loop:
; CHECK: tail call i8* @objc_retain(i8* %x)
; CHECK: exit:
; CHECK: call void @objc_release(i8* %x)
; CHECK: }
define void @test64(i8* %x, i1* %p) nounwind {
entry:
br label %loop
loop:
call i8* @objc_retain(i8* %x)
%q = load i1, i1* %p
br i1 %q, label %loop.more, label %exit
loop.more:
br label %loop
exit:
call void @objc_release(i8* %x)
ret void
}
; Move an autorelease past a phi with a null.
; CHECK-LABEL: define i8* @test65(
; CHECK: if.then:
; CHECK: call i8* @objc_autorelease(
; CHECK: return:
; CHECK-NOT: @objc_autorelease
; CHECK: }
define i8* @test65(i1 %x) {
entry:
br i1 %x, label %return, label %if.then
if.then: ; preds = %entry
%c = call i8* @returner()
%s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
br label %return
return: ; preds = %if.then, %entry
%retval = phi i8* [ %s, %if.then ], [ null, %entry ]
%q = call i8* @objc_autorelease(i8* %retval) nounwind
ret i8* %retval
}
; Don't move an autorelease past an autorelease pool boundary.
; CHECK-LABEL: define i8* @test65b(
; CHECK: if.then:
; CHECK-NOT: @objc_autorelease
; CHECK: return:
; CHECK: call i8* @objc_autorelease(
; CHECK: }
define i8* @test65b(i1 %x) {
entry:
%t = call i8* @objc_autoreleasePoolPush()
br i1 %x, label %return, label %if.then
if.then: ; preds = %entry
%c = call i8* @returner()
%s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
br label %return
return: ; preds = %if.then, %entry
%retval = phi i8* [ %s, %if.then ], [ null, %entry ]
call void @objc_autoreleasePoolPop(i8* %t)
%q = call i8* @objc_autorelease(i8* %retval) nounwind
ret i8* %retval
}
; Don't move an autoreleaseReuturnValue, which would break
; the RV optimization.
; CHECK-LABEL: define i8* @test65c(
; CHECK: if.then:
; CHECK-NOT: @objc_autorelease
; CHECK: return:
; CHECK: call i8* @objc_autoreleaseReturnValue(
; CHECK: }
define i8* @test65c(i1 %x) {
entry:
br i1 %x, label %return, label %if.then
if.then: ; preds = %entry
%c = call i8* @returner()
%s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
br label %return
return: ; preds = %if.then, %entry
%retval = phi i8* [ %s, %if.then ], [ null, %entry ]
%q = call i8* @objc_autoreleaseReturnValue(i8* %retval) nounwind
ret i8* %retval
}
; An objc_retain can serve as a may-use for a different pointer.
; rdar://11931823
; CHECK-LABEL: define void @test66a(
; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
; CHECK: }
define void @test66a(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
entry:
br i1 %tobool, label %cond.true, label %cond.end
cond.true:
br label %cond.end
cond.end: ; preds = %cond.true, %entry
%cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
%tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
tail call void @objc_release(i8* %call) nounwind
%tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
%tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
tail call void @objc_release(i8* %cond) nounwind
ret void
}
; CHECK-LABEL: define void @test66b(
; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
; CHECK: }
define void @test66b(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
entry:
br i1 %tobool, label %cond.true, label %cond.end
cond.true:
br label %cond.end
cond.end: ; preds = %cond.true, %entry
%cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
%tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
%tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
%tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
tail call void @objc_release(i8* %cond) nounwind
ret void
}
; CHECK-LABEL: define void @test66c(
; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
; CHECK: }
define void @test66c(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
entry:
br i1 %tobool, label %cond.true, label %cond.end
cond.true:
br label %cond.end
cond.end: ; preds = %cond.true, %entry
%cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
%tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
tail call void @objc_release(i8* %call) nounwind
%tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
%tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind, !clang.imprecise_release !0
tail call void @objc_release(i8* %cond) nounwind
ret void
}
; CHECK-LABEL: define void @test66d(
; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
; CHECK: }
define void @test66d(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
entry:
br i1 %tobool, label %cond.true, label %cond.end
cond.true:
br label %cond.end
cond.end: ; preds = %cond.true, %entry
%cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
%tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
%tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
%tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
tail call void @objc_release(i8* %cond) nounwind, !clang.imprecise_release !0
ret void
}
; A few real-world testcases.
@.str4 = private unnamed_addr constant [33 x i8] c"-[A z] = { %f, %f, { %f, %f } }\0A\00"
@"OBJC_IVAR_$_A.myZ" = global i64 20, section "__DATA, __objc_const", align 8
declare i32 @printf(i8* nocapture, ...) nounwind
declare i32 @puts(i8* nocapture) nounwind
@str = internal constant [16 x i8] c"-[ Top0 _getX ]\00"
; CHECK: define { <2 x float>, <2 x float> } @"\01-[A z]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
; CHECK-NOT: @objc_
; CHECK: }
define {<2 x float>, <2 x float>} @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind {
invoke.cont:
%0 = bitcast {}* %self to i8*
%1 = tail call i8* @objc_retain(i8* %0) nounwind
tail call void @llvm.dbg.value(metadata {}* %self, i64 0, metadata !MDLocalVariable(tag: DW_TAG_auto_variable), metadata !MDExpression())
tail call void @llvm.dbg.value(metadata {}* %self, i64 0, metadata !MDLocalVariable(tag: DW_TAG_auto_variable), metadata !MDExpression())
%ivar = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
%add.ptr = getelementptr i8, i8* %0, i64 %ivar
%tmp1 = bitcast i8* %add.ptr to float*
%tmp2 = load float, float* %tmp1, align 4
%conv = fpext float %tmp2 to double
%add.ptr.sum = add i64 %ivar, 4
%tmp6 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum
%2 = bitcast i8* %tmp6 to float*
%tmp7 = load float, float* %2, align 4
%conv8 = fpext float %tmp7 to double
%add.ptr.sum36 = add i64 %ivar, 8
%tmp12 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum36
%arrayidx = bitcast i8* %tmp12 to float*
%tmp13 = load float, float* %arrayidx, align 4
%conv14 = fpext float %tmp13 to double
%tmp12.sum = add i64 %ivar, 12
%arrayidx19 = getelementptr inbounds i8, i8* %0, i64 %tmp12.sum
%3 = bitcast i8* %arrayidx19 to float*
%tmp20 = load float, float* %3, align 4
%conv21 = fpext float %tmp20 to double
%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)
%ivar23 = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
%add.ptr24 = getelementptr i8, i8* %0, i64 %ivar23
%4 = bitcast i8* %add.ptr24 to i128*
%srcval = load i128, i128* %4, align 4
tail call void @objc_release(i8* %0) nounwind
%tmp29 = trunc i128 %srcval to i64
%tmp30 = bitcast i64 %tmp29 to <2 x float>
%tmp31 = insertvalue {<2 x float>, <2 x float>} undef, <2 x float> %tmp30, 0
%tmp32 = lshr i128 %srcval, 64
%tmp33 = trunc i128 %tmp32 to i64
%tmp34 = bitcast i64 %tmp33 to <2 x float>
%tmp35 = insertvalue {<2 x float>, <2 x float>} %tmp31, <2 x float> %tmp34, 1
ret {<2 x float>, <2 x float>} %tmp35
}
; CHECK: @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
; CHECK-NOT: @objc_
; CHECK: }
define i32 @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) nounwind {
invoke.cont:
%0 = bitcast {}* %self to i8*
%1 = tail call i8* @objc_retain(i8* %0) nounwind
%puts = tail call i32 @puts(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str, i64 0, i64 0))
tail call void @objc_release(i8* %0) nounwind
ret i32 0
}
@"\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"
@"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip"
@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"
; A simple loop. Eliminate the retain and release inside of it!
; CHECK: define void @loop(i8* %x, i64 %n) {
; CHECK: for.body:
; CHECK-NOT: @objc_
; CHECK: @objc_msgSend
; CHECK-NOT: @objc_
; CHECK: for.end:
; CHECK: }
define void @loop(i8* %x, i64 %n) {
entry:
%0 = tail call i8* @objc_retain(i8* %x) nounwind
%cmp9 = icmp sgt i64 %n, 0
br i1 %cmp9, label %for.body, label %for.end
for.body: ; preds = %entry, %for.body
%i.010 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%1 = tail call i8* @objc_retain(i8* %x) nounwind
%tmp5 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8
%call = tail call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %1, i8* %tmp5)
tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
%inc = add nsw i64 %i.010, 1
%exitcond = icmp eq i64 %inc, %n
br i1 %exitcond, label %for.end, label %for.body
for.end: ; preds = %for.body, %entry
tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
ret void
}
; ObjCARCOpt can delete the retain,release on self.
; CHECK: define void @TextEditTest(%2* %self, %3* %pboard) {
; CHECK-NOT: call i8* @objc_retain(i8* %tmp7)
; CHECK: }
%0 = type { i8* (i8*, %struct._message_ref_t*, ...)*, i8* }
%1 = type opaque
%2 = type opaque
%3 = type opaque
%4 = type opaque
%5 = type opaque
%struct.NSConstantString = type { i32*, i32, i8*, i64 }
%struct._NSRange = type { i64, i64 }
%struct.__CFString = type opaque
%struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
%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* }
%struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
%struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
%struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
%struct._message_ref_t = type { i8*, i8* }
%struct._objc_cache = type opaque
%struct._objc_method = type { i8*, i8*, i8* }
%struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
%struct._prop_list_t = type { i32, i32, [0 x %struct._message_ref_t] }
%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 }
@"\01L_OBJC_CLASSLIST_REFERENCES_$_17" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
@kUTTypePlainText = external constant %struct.__CFString*
@"\01L_OBJC_SELECTOR_REFERENCES_19" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_21" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_23" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_25" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_CLASSLIST_REFERENCES_$_26" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
@"\01L_OBJC_SELECTOR_REFERENCES_28" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_CLASSLIST_REFERENCES_$_29" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
@"\01L_OBJC_SELECTOR_REFERENCES_31" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_33" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_35" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_37" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_CLASSLIST_REFERENCES_$_38" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
@"\01L_OBJC_SELECTOR_REFERENCES_40" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_42" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@_unnamed_cfstring_44 = external hidden constant %struct.NSConstantString, section "__DATA,__cfstring"
@"\01L_OBJC_SELECTOR_REFERENCES_46" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_48" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01l_objc_msgSend_fixup_isEqual_" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16
@"\01L_OBJC_CLASSLIST_REFERENCES_$_50" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
@NSCocoaErrorDomain = external constant %1*
@"\01L_OBJC_CLASSLIST_REFERENCES_$_51" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
@NSFilePathErrorKey = external constant %1*
@"\01L_OBJC_SELECTOR_REFERENCES_53" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_55" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_CLASSLIST_REFERENCES_$_56" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
@"\01L_OBJC_SELECTOR_REFERENCES_58" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
@"\01L_OBJC_SELECTOR_REFERENCES_60" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
declare %1* @truncatedString(%1*, i64)
define void @TextEditTest(%2* %self, %3* %pboard) {
entry:
%err = alloca %4*, align 8
%tmp7 = bitcast %2* %self to i8*
%tmp8 = call i8* @objc_retain(i8* %tmp7) nounwind
store %4* null, %4** %err, align 8
%tmp1 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_17", align 8
%tmp2 = load %struct.__CFString*, %struct.__CFString** @kUTTypePlainText, align 8
%tmp3 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_19", align 8
%tmp4 = bitcast %struct._class_t* %tmp1 to i8*
%call5 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp4, i8* %tmp3, %struct.__CFString* %tmp2)
%tmp5 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_21", align 8
%tmp6 = bitcast %3* %pboard to i8*
%call76 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp5, i8* %call5)
%tmp9 = call i8* @objc_retain(i8* %call76) nounwind
%tobool = icmp eq i8* %tmp9, null
br i1 %tobool, label %end, label %land.lhs.true
land.lhs.true: ; preds = %entry
%tmp11 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_23", align 8
%call137 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp11, i8* %tmp9)
%tmp = bitcast i8* %call137 to %1*
%tmp10 = call i8* @objc_retain(i8* %call137) nounwind
call void @objc_release(i8* null) nounwind
%tmp12 = call i8* @objc_retain(i8* %call137) nounwind
call void @objc_release(i8* null) nounwind
%tobool16 = icmp eq i8* %call137, null
br i1 %tobool16, label %end, label %if.then
if.then: ; preds = %land.lhs.true
%tmp19 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
%call21 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %call137, i8* %tmp19)
%tobool22 = icmp eq i8 %call21, 0
br i1 %tobool22, label %if.then44, label %land.lhs.true23
land.lhs.true23: ; preds = %if.then
%tmp24 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
%tmp26 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
%tmp27 = bitcast %struct._class_t* %tmp24 to i8*
%call2822 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp27, i8* %tmp26, i8* %call137)
%tmp13 = bitcast i8* %call2822 to %5*
%tmp14 = call i8* @objc_retain(i8* %call2822) nounwind
call void @objc_release(i8* null) nounwind
%tobool30 = icmp eq i8* %call2822, null
br i1 %tobool30, label %if.then44, label %if.end
if.end: ; preds = %land.lhs.true23
%tmp32 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
%tmp33 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
%tmp34 = bitcast %struct._class_t* %tmp32 to i8*
%call35 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp34, i8* %tmp33)
%tmp37 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
%call3923 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call35, i8* %tmp37, i8* %call2822, i32 signext 1, %4** %err)
%cmp = icmp eq i8* %call3923, null
br i1 %cmp, label %if.then44, label %end
if.then44: ; preds = %if.end, %land.lhs.true23, %if.then
%url.025 = phi %5* [ %tmp13, %if.end ], [ %tmp13, %land.lhs.true23 ], [ null, %if.then ]
%tmp49 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_35", align 8
%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)
%call513 = extractvalue %struct._NSRange %call51, 0
%call514 = extractvalue %struct._NSRange %call51, 1
%tmp52 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_37", align 8
%call548 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call137, i8* %tmp52, i64 %call513, i64 %call514)
%tmp55 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_38", align 8
%tmp56 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_40", align 8
%tmp57 = bitcast %struct._class_t* %tmp55 to i8*
%call58 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp57, i8* %tmp56)
%tmp59 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_42", align 8
%call6110 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call548, i8* %tmp59, i8* %call58)
%tmp15 = call i8* @objc_retain(i8* %call6110) nounwind
call void @objc_release(i8* %call137) nounwind
%tmp64 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_46", align 8
%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*))
%tobool67 = icmp eq i8 %call66, 0
br i1 %tobool67, label %if.end74, label %if.then68
if.then68: ; preds = %if.then44
%tmp70 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_48", align 8
%call7220 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call6110, i8* %tmp70)
%tmp16 = call i8* @objc_retain(i8* %call7220) nounwind
call void @objc_release(i8* %call6110) nounwind
br label %if.end74
if.end74: ; preds = %if.then68, %if.then44
%filename.0.in = phi i8* [ %call7220, %if.then68 ], [ %call6110, %if.then44 ]
%filename.0 = bitcast i8* %filename.0.in to %1*
%tmp17 = load i8*, i8** bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to i8**), align 16
%tmp18 = bitcast i8* %tmp17 to i8 (i8*, %struct._message_ref_t*, i8*, ...)*
%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)
%tobool79 = icmp eq i8 %call78, 0
br i1 %tobool79, label %land.lhs.true80, label %if.then109
land.lhs.true80: ; preds = %if.end74
%tmp82 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
%call84 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %filename.0.in, i8* %tmp82)
%tobool86 = icmp eq i8 %call84, 0
br i1 %tobool86, label %if.then109, label %if.end106
if.end106: ; preds = %land.lhs.true80
%tmp88 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
%tmp90 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
%tmp91 = bitcast %struct._class_t* %tmp88 to i8*
%call9218 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp91, i8* %tmp90, i8* %filename.0.in)
%tmp20 = bitcast i8* %call9218 to %5*
%tmp21 = call i8* @objc_retain(i8* %call9218) nounwind
%tmp22 = bitcast %5* %url.025 to i8*
call void @objc_release(i8* %tmp22) nounwind
%tmp94 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
%tmp95 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
%tmp96 = bitcast %struct._class_t* %tmp94 to i8*
%call97 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp96, i8* %tmp95)
%tmp99 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
%call10119 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call97, i8* %tmp99, i8* %call9218, i32 signext 1, %4** %err)
%phitmp = icmp eq i8* %call10119, null
br i1 %phitmp, label %if.then109, label %end
if.then109: ; preds = %if.end106, %land.lhs.true80, %if.end74
%url.129 = phi %5* [ %tmp20, %if.end106 ], [ %url.025, %if.end74 ], [ %url.025, %land.lhs.true80 ]
%tmp110 = load %4*, %4** %err, align 8
%tobool111 = icmp eq %4* %tmp110, null
br i1 %tobool111, label %if.then112, label %if.end125
if.then112: ; preds = %if.then109
%tmp113 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_50", align 8
%tmp114 = load %1*, %1** @NSCocoaErrorDomain, align 8
%tmp115 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_51", align 8
%call117 = call %1* @truncatedString(%1* %filename.0, i64 1034)
%tmp118 = load %1*, %1** @NSFilePathErrorKey, align 8
%tmp119 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_53", align 8
%tmp120 = bitcast %struct._class_t* %tmp115 to i8*
%call12113 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp120, i8* %tmp119, %1* %call117, %1* %tmp118, i8* null)
%tmp122 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_55", align 8
%tmp123 = bitcast %struct._class_t* %tmp113 to i8*
%call12414 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp123, i8* %tmp122, %1* %tmp114, i64 258, i8* %call12113)
%tmp23 = call i8* @objc_retain(i8* %call12414) nounwind
%tmp25 = call i8* @objc_autorelease(i8* %tmp23) nounwind
%tmp28 = bitcast i8* %tmp25 to %4*
store %4* %tmp28, %4** %err, align 8
br label %if.end125
if.end125: ; preds = %if.then112, %if.then109
%tmp127 = phi %4* [ %tmp110, %if.then109 ], [ %tmp28, %if.then112 ]
%tmp126 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_56", align 8
%tmp128 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_58", align 8
%tmp129 = bitcast %struct._class_t* %tmp126 to i8*
%call13015 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp129, i8* %tmp128, %4* %tmp127)
%tmp131 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_60", align 8
%call13317 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call13015, i8* %tmp131)
br label %end
end: ; preds = %if.end125, %if.end106, %if.end, %land.lhs.true, %entry
%filename.2 = phi %1* [ %filename.0, %if.end106 ], [ %filename.0, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
%origFilename.0 = phi %1* [ %tmp, %if.end106 ], [ %tmp, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
%url.2 = phi %5* [ %tmp20, %if.end106 ], [ %url.129, %if.end125 ], [ null, %land.lhs.true ], [ null, %entry ], [ %tmp13, %if.end ]
call void @objc_release(i8* %tmp9) nounwind, !clang.imprecise_release !0
%tmp29 = bitcast %5* %url.2 to i8*
call void @objc_release(i8* %tmp29) nounwind, !clang.imprecise_release !0
%tmp30 = bitcast %1* %origFilename.0 to i8*
call void @objc_release(i8* %tmp30) nounwind, !clang.imprecise_release !0
%tmp31 = bitcast %1* %filename.2 to i8*
call void @objc_release(i8* %tmp31) nounwind, !clang.imprecise_release !0
call void @objc_release(i8* %tmp7) nounwind, !clang.imprecise_release !0
ret void
}
declare i32 @__gxx_personality_v0(...)
declare i32 @objc_sync_enter(i8*)
declare i32 @objc_sync_exit(i8*)
; Make sure that we understand that objc_sync_{enter,exit} are IC_User not
; IC_Call/IC_CallOrUser.
; CHECK-LABEL: define void @test67(
; CHECK-NEXT: call i32 @objc_sync_enter(i8* %x)
; CHECK-NEXT: call i32 @objc_sync_exit(i8* %x)
; CHECK-NEXT: ret void
; CHECK-NEXT: }
define void @test67(i8* %x) {
call i8* @objc_retain(i8* %x)
call i32 @objc_sync_enter(i8* %x)
call i32 @objc_sync_exit(i8* %x)
call void @objc_release(i8* %x), !clang.imprecise_release !0
ret void
}
!llvm.module.flags = !{!1}
!0 = !{}
!1 = !{i32 1, !"Debug Info Version", i32 3}
; CHECK: attributes #0 = { nounwind readnone }
; CHECK: attributes [[NUW]] = { nounwind }
; CHECK: ![[RELEASE]] = !{}
Reference in New Issue View Git Blame Copy Permalink