RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-01-31 20:51:52 +01:00
Code Issues Projects Releases Wiki Activity
llvm-mirror/test/Transforms/ObjCARC/allocas.ll
Pete Cooper f6c9646a94 Change the objc ARC optimizer to use the new objc.* intrinsics 
We're moving ARC optimisation and ARC emission in clang away from runtime methods
and towards intrinsics.  This is the part which actually uses the intrinsics in the ARC
optimizer when both analyzing the existing calls and emitting new ones.

Differential Revision: https://reviews.llvm.org/D55348

Reviewers: ahatanak
llvm-svn: 349534
2018-12-18 20:32:49 +00:00

501 lines
16 KiB
LLVM
Raw Blame History

; RUN: opt -objc-arc -S < %s | FileCheck %s
declare i8* @llvm.objc.retain(i8*)
declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
declare void @llvm.objc.release(i8*)
declare i8* @llvm.objc.autorelease(i8*)
declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
declare void @llvm.objc.autoreleasePoolPop(i8*)
declare i8* @llvm.objc.autoreleasePoolPush()
declare i8* @llvm.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 i8* @returner1()
declare i8* @returner2()
declare void @bar(i32 ()*)
declare void @use_alloca(i8**)
declare void @llvm.dbg.value(metadata, metadata, metadata)
declare i8* @llvm.objc.msgSend(i8*, i8*, ...)
; In the presence of allocas, unconditionally remove retain/release pairs only
; if they are known safe in both directions. This prevents matching up an inner
; retain with the boundary guarding release in the following situation:
;
; %A = alloca
; retain(%x)
; retain(%x) <--- Inner Retain
; store %x, %A
; %y = load %A
; ... DO STUFF ...
; release(%y)
; release(%x) <--- Guarding Release
;
; rdar://13750319
; CHECK: define void @test1a(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test1a(i8* %x) {
entry:
%A = alloca i8*
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
store i8* %x, i8** %A, align 8
%y = load i8*, i8** %A
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test1b(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test1b(i8* %x) {
entry:
%A = alloca i8*
%gep = getelementptr i8*, i8** %A, i32 0
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
store i8* %x, i8** %gep, align 8
%y = load i8*, i8** %A
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test1c(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test1c(i8* %x) {
entry:
%A = alloca i8*, i32 3
%gep = getelementptr i8*, i8** %A, i32 2
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
store i8* %x, i8** %gep, align 8
%y = load i8*, i8** %gep
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test1d(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test1d(i8* %x) {
entry:
br i1 undef, label %use_allocaA, label %use_allocaB
use_allocaA:
%allocaA = alloca i8*
br label %exit
use_allocaB:
%allocaB = alloca i8*
br label %exit
exit:
%A = phi i8** [ %allocaA, %use_allocaA ], [ %allocaB, %use_allocaB ]
%gep = getelementptr i8*, i8** %A, i32 0
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
store i8* %x, i8** %gep, align 8
%y = load i8*, i8** %gep
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test1e(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test1e(i8* %x) {
entry:
br i1 undef, label %use_allocaA, label %use_allocaB
use_allocaA:
%allocaA = alloca i8*, i32 4
br label %exit
use_allocaB:
%allocaB = alloca i8*, i32 4
br label %exit
exit:
%A = phi i8** [ %allocaA, %use_allocaA ], [ %allocaB, %use_allocaB ]
%gep = getelementptr i8*, i8** %A, i32 2
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
store i8* %x, i8** %gep, align 8
%y = load i8*, i8** %gep
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test1f(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test1f(i8* %x) {
entry:
%allocaOne = alloca i8*
%allocaTwo = alloca i8*
%A = select i1 undef, i8** %allocaOne, i8** %allocaTwo
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
store i8* %x, i8** %A, align 8
%y = load i8*, i8** %A
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; Make sure that if a store is in a different basic block we handle known safe
; conservatively.
; CHECK: define void @test2a(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test2a(i8* %x) {
entry:
%A = alloca i8*
store i8* %x, i8** %A, align 8
%y = load i8*, i8** %A
br label %bb1
bb1:
br label %bb2
bb2:
br label %bb3
bb3:
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test2b(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test2b(i8* %x) {
entry:
%A = alloca i8*
%gep1 = getelementptr i8*, i8** %A, i32 0
store i8* %x, i8** %gep1, align 8
%gep2 = getelementptr i8*, i8** %A, i32 0
%y = load i8*, i8** %gep2
br label %bb1
bb1:
br label %bb2
bb2:
br label %bb3
bb3:
tail call i8* @llvm.objc.retain(i8* %x)
tail call i8* @llvm.objc.retain(i8* %x)
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test2c(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test2c(i8* %x) {
entry:
%A = alloca i8*, i32 3
%gep1 = getelementptr i8*, i8** %A, i32 2
store i8* %x, i8** %gep1, align 8
%gep2 = getelementptr i8*, i8** %A, i32 2
%y = load i8*, i8** %gep2
tail call i8* @llvm.objc.retain(i8* %x)
br label %bb1
bb1:
br label %bb2
bb2:
br label %bb3
bb3:
tail call i8* @llvm.objc.retain(i8* %x)
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; CHECK: define void @test2d(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.retain(i8* %x)
; CHECK: @llvm.objc.release(i8* %y)
; CHECK: @llvm.objc.release(i8* %x)
; CHECK: ret void
; CHECK: }
define void @test2d(i8* %x) {
entry:
tail call i8* @llvm.objc.retain(i8* %x)
br label %bb1
bb1:
%Abb1 = alloca i8*, i32 3
%gepbb11 = getelementptr i8*, i8** %Abb1, i32 2
store i8* %x, i8** %gepbb11, align 8
%gepbb12 = getelementptr i8*, i8** %Abb1, i32 2
%ybb1 = load i8*, i8** %gepbb12
br label %bb3
bb2:
%Abb2 = alloca i8*, i32 4
%gepbb21 = getelementptr i8*, i8** %Abb2, i32 2
store i8* %x, i8** %gepbb21, align 8
%gepbb22 = getelementptr i8*, i8** %Abb2, i32 2
%ybb2 = load i8*, i8** %gepbb22
br label %bb3
bb3:
%A = phi i8** [ %Abb1, %bb1 ], [ %Abb2, %bb2 ]
%y = phi i8* [ %ybb1, %bb1 ], [ %ybb2, %bb2 ]
tail call i8* @llvm.objc.retain(i8* %x)
call void @use_alloca(i8** %A)
call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
call void @use_pointer(i8* %x)
call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
ret void
}
; Make sure in the presence of allocas, if we find a cfghazard we do not perform
; code motion even if we are known safe. These two concepts are separate and
; should be treated as such.
;
; rdar://13949644
; CHECK: define void @test3a() {
; CHECK: entry:
; CHECK: @llvm.objc.retainAutoreleasedReturnValue
; CHECK: @llvm.objc.retain
; CHECK: @llvm.objc.retain
; CHECK: @llvm.objc.retain
; CHECK: @llvm.objc.retain
; CHECK: arraydestroy.body:
; CHECK: @llvm.objc.release
; CHECK-NOT: @llvm.objc.release
; CHECK: arraydestroy.done:
; CHECK-NOT: @llvm.objc.release
; CHECK: arraydestroy.body1:
; CHECK: @llvm.objc.release
; CHECK-NOT: @llvm.objc.release
; CHECK: arraydestroy.done1:
; CHECK: @llvm.objc.release
; CHECK: ret void
; CHECK: }
define void @test3a() {
entry:
%keys = alloca [2 x i8*], align 16
%objs = alloca [2 x i8*], align 16
%call1 = call i8* @returner()
%tmp0 = tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %call1)
%objs.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
tail call i8* @llvm.objc.retain(i8* %call1)
store i8* %call1, i8** %objs.begin, align 8
%objs.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 1
tail call i8* @llvm.objc.retain(i8* %call1)
store i8* %call1, i8** %objs.elt
%call2 = call i8* @returner1()
%call3 = call i8* @returner2()
%keys.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
tail call i8* @llvm.objc.retain(i8* %call2)
store i8* %call2, i8** %keys.begin, align 8
%keys.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 1
tail call i8* @llvm.objc.retain(i8* %call3)
store i8* %call3, i8** %keys.elt
%gep = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 2
br label %arraydestroy.body
arraydestroy.body:
%arraydestroy.elementPast = phi i8** [ %gep, %entry ], [ %arraydestroy.element, %arraydestroy.body ]
%arraydestroy.element = getelementptr inbounds i8*, i8** %arraydestroy.elementPast, i64 -1
%destroy_tmp = load i8*, i8** %arraydestroy.element, align 8
call void @llvm.objc.release(i8* %destroy_tmp), !clang.imprecise_release !0
%objs_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
%arraydestroy.cmp = icmp eq i8** %arraydestroy.element, %objs_ptr
br i1 %arraydestroy.cmp, label %arraydestroy.done, label %arraydestroy.body
arraydestroy.done:
%gep1 = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 2
br label %arraydestroy.body1
arraydestroy.body1:
%arraydestroy.elementPast1 = phi i8** [ %gep1, %arraydestroy.done ], [ %arraydestroy.element1, %arraydestroy.body1 ]
%arraydestroy.element1 = getelementptr inbounds i8*, i8** %arraydestroy.elementPast1, i64 -1
%destroy_tmp1 = load i8*, i8** %arraydestroy.element1, align 8
call void @llvm.objc.release(i8* %destroy_tmp1), !clang.imprecise_release !0
%keys_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
%arraydestroy.cmp1 = icmp eq i8** %arraydestroy.element1, %keys_ptr
br i1 %arraydestroy.cmp1, label %arraydestroy.done1, label %arraydestroy.body1
arraydestroy.done1:
call void @llvm.objc.release(i8* %call1), !clang.imprecise_release !0
ret void
}
; Make sure that even though we stop said code motion we still allow for
; pointers to be removed if we are known safe in both directions.
;
; rdar://13949644
; CHECK: define void @test3b() {
; CHECK: entry:
; CHECK: @llvm.objc.retainAutoreleasedReturnValue
; CHECK: @llvm.objc.retain
; CHECK: @llvm.objc.retain
; CHECK: @llvm.objc.retain
; CHECK: @llvm.objc.retain
; CHECK: arraydestroy.body:
; CHECK: @llvm.objc.release
; CHECK-NOT: @llvm.objc.release
; CHECK: arraydestroy.done:
; CHECK-NOT: @llvm.objc.release
; CHECK: arraydestroy.body1:
; CHECK: @llvm.objc.release
; CHECK-NOT: @llvm.objc.release
; CHECK: arraydestroy.done1:
; CHECK: @llvm.objc.release
; CHECK: ret void
; CHECK: }
define void @test3b() {
entry:
%keys = alloca [2 x i8*], align 16
%objs = alloca [2 x i8*], align 16
%call1 = call i8* @returner()
%tmp0 = tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %call1)
%tmp1 = tail call i8* @llvm.objc.retain(i8* %call1)
%objs.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
tail call i8* @llvm.objc.retain(i8* %call1)
store i8* %call1, i8** %objs.begin, align 8
%objs.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 1
tail call i8* @llvm.objc.retain(i8* %call1)
store i8* %call1, i8** %objs.elt
%call2 = call i8* @returner1()
%call3 = call i8* @returner2()
%keys.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
tail call i8* @llvm.objc.retain(i8* %call2)
store i8* %call2, i8** %keys.begin, align 8
%keys.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 1
tail call i8* @llvm.objc.retain(i8* %call3)
store i8* %call3, i8** %keys.elt
%gep = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 2
br label %arraydestroy.body
arraydestroy.body:
%arraydestroy.elementPast = phi i8** [ %gep, %entry ], [ %arraydestroy.element, %arraydestroy.body ]
%arraydestroy.element = getelementptr inbounds i8*, i8** %arraydestroy.elementPast, i64 -1
%destroy_tmp = load i8*, i8** %arraydestroy.element, align 8
call void @llvm.objc.release(i8* %destroy_tmp), !clang.imprecise_release !0
%objs_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
%arraydestroy.cmp = icmp eq i8** %arraydestroy.element, %objs_ptr
br i1 %arraydestroy.cmp, label %arraydestroy.done, label %arraydestroy.body
arraydestroy.done:
%gep1 = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 2
br label %arraydestroy.body1
arraydestroy.body1:
%arraydestroy.elementPast1 = phi i8** [ %gep1, %arraydestroy.done ], [ %arraydestroy.element1, %arraydestroy.body1 ]
%arraydestroy.element1 = getelementptr inbounds i8*, i8** %arraydestroy.elementPast1, i64 -1
%destroy_tmp1 = load i8*, i8** %arraydestroy.element1, align 8
call void @llvm.objc.release(i8* %destroy_tmp1), !clang.imprecise_release !0
%keys_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
%arraydestroy.cmp1 = icmp eq i8** %arraydestroy.element1, %keys_ptr
br i1 %arraydestroy.cmp1, label %arraydestroy.done1, label %arraydestroy.body1
arraydestroy.done1:
call void @llvm.objc.release(i8* %call1), !clang.imprecise_release !0
call void @llvm.objc.release(i8* %call1), !clang.imprecise_release !0
ret void
}
!0 = !{}
declare i32 @__gxx_personality_v0(...)
Reference in New Issue View Git Blame Copy Permalink