diff options
author | John McCall <rjmccall@apple.com> | 2011-06-15 23:37:01 +0000 |
---|---|---|
committer | John McCall <rjmccall@apple.com> | 2011-06-15 23:37:01 +0000 |
commit | 9fbd318d36e618fb08fb53bb48b7c848e617a8a7 (patch) | |
tree | 734b59edd4958b31e22b6cbd005df15fdd8ab78b /test/Transforms | |
parent | 5f36bb1759e35bd3aef4b6ce226e091849f6b816 (diff) | |
download | llvm-9fbd318d36e618fb08fb53bb48b7c848e617a8a7.tar.gz llvm-9fbd318d36e618fb08fb53bb48b7c848e617a8a7.tar.bz2 llvm-9fbd318d36e618fb08fb53bb48b7c848e617a8a7.tar.xz |
The ARC language-specific optimizer. Credit to Dan Gohman.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@133108 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'test/Transforms')
19 files changed, 3383 insertions, 0 deletions
diff --git a/test/Transforms/ObjCARC/basic.ll b/test/Transforms/ObjCARC/basic.ll new file mode 100644 index 0000000000..a6bbf8674b --- /dev/null +++ b/test/Transforms/ObjCARC/basic.ll @@ -0,0 +1,1898 @@ +; RUN: opt -objc-arc -S < %s | FileCheck %s + +target datalayout = "e-p:64:64:64" + +declare i8* @objc_retain(i8*) +declare void @objc_release(i8*) +declare i8* @objc_autorelease(i8*) +declare void @objc_autoreleasePoolPop(i8*) +declare void @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 @llvm.dbg.value(metadata, i64, metadata) + +declare i8* @objc_msgSend(i8*, i8*, ...) + +; Simple retain+release pair deletion, with some intervening control +; flow and harmless instructions. + +; CHECK: define void @test0( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test0(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 +} + +; 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( +; CHECK: @objc_retain(i8* %a) +; CHECK: @objc_release +; CHECK: } +define void @test1(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 +} + +; Like test0 but the pointer is passed to an intervening call, +; so the optimization is not safe. + +; CHECK: define void @test2( +; CHECK: @objc_retain(i8* %a) +; CHECK: @objc_release +; CHECK: } +define void @test2(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 +} + +; Like test0 but the release is in a loop, +; so the optimization is not safe. + +; TODO: For now, assume this can't happen. + +; CHECK: define void @test3( +; TODO: @objc_retain(i8* %a) +; TODO: @objc_release +; CHECK: } +define void @test3(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 = volatile load 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: define void @test4( +; TODO: @objc_retain(i8* %a) +; TODO: @objc_release +; CHECK: } +define void @test4(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 = volatile load 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 +} + +; Like test0 but the pointer is conditionally passed to an intervening call, +; so the optimization is not safe. + +; CHECK: define void @test5( +; CHECK: @objc_retain(i8* +; CHECK: @objc_release +; CHECK: } +define void @test5(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 +} + +; retain+release pair deletion, where the release happens on two different +; flow paths. + +; CHECK: define void @test6( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test6(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 +} + +; retain+release pair deletion, where the retain happens on two different +; flow paths. + +; CHECK: define void @test7( +; CHECK-NOT: @objc_ +; 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 +} + +; Like test7, but there's a retain/retainBlock mismatch. Don't delete! + +; CHECK: define void @test7b +; CHECK: t: +; CHECK: call i8* @objc_retainBlock +; CHECK: f: +; CHECK: call i8* @objc_retain +; CHECK: return: +; CHECK: call void @objc_release +; 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_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: define void @test8( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test8(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 +} + +; Trivial retain+release pair deletion. + +; CHECK: 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: 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: define void @test10( +; CHECK: @objc_retain(i8* %x) +; CHECK: @use_pointer +; CHECK: @objc_release +; CHECK: } +define void @test10(i8* %x) nounwind { +entry: + %0 = call i8* @objc_retain(i8* %x) nounwind + call void @use_pointer(i8* %x) + 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: define void @test11( +; CHECK: tail call i8* @objc_retain(i8* %x) nounwind +; CHECK: tail call i8* @objc_autorelease(i8* %0) nounwind +; 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: 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 an RV optimization. + +; CHECK: define i8* @test11b( +; CHECK: tail call i8* @objc_retain(i8* %x) nounwind +; CHECK: tail call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind +; 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 +} + +; Trivial retain,release pair with intervening call, but it's dominated +; by another retain - delete! + +; CHECK: define void @test12( +; CHECK-NEXT: entry: +; CHECK-NEXT: @objc_retain(i8* %x) +; CHECK-NOT: @objc_ +; 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: define void @test13( +; CHECK: tail call i8* @objc_retain(i8* %x) nounwind +; CHECK: tail call i8* @objc_retain(i8* %x) nounwind +; CHECK: @use_pointer(i8* %x) +; CHECK: tail call i8* @objc_autorelease(i8* %x) nounwind +; 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: define void @test13b +; CHECK-NEXT: entry: +; CHECK-NEXT: @objc_retain(i8* %x) +; CHECK-NEXT: @use_pointer +; CHECK-NEXT: @use_pointer +; CHECK-NEXT: ret void +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 + ret void +} + +; Don't delete the retain+release pair because there's an +; autoreleasePoolPop in the way. + +; CHECK: 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: 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: ret void +define void @test13d(i8* %x, i64 %n) { +entry: + call i8* @objc_retain(i8* %x) nounwind + call void @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 + ret void +} + +; Trivial retain,release pair with intervening call, but it's post-dominated +; by another release - delete! + +; CHECK: define void @test14( +; CHECK-NEXT: entry: +; CHECK-NEXT: @use_pointer +; CHECK-NEXT: @use_pointer +; 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: 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: define void @test15b +; CHECK-NEXT: entry: +; CHECK-NEXT: @objc_autorelease +; 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 +} + +; Retain+release pairs in diamonds, all dominated by a retain. + +; CHECK: define void @test16( +; CHECK: @objc_retain(i8* %x) +; CHECK-NOT: @objc +; CHECK: } +define void @test16(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: + ret void +} + +; Retain+release pairs in diamonds, all post-dominated by a release. + +; CHECK: define void @test17( +; CHECK-NOT: @objc_ +; CHECK: purple: +; CHECK: @objc_release +; CHECK: } +define void @test17(i1 %a, i1 %b, i8* %x) { +entry: + 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 @objc_release(i8* %x) nounwind + ret void +} + +; Delete no-ops. + +; CHECK: 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: 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: define void @test20( +; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) nounwind +; CHECK-NEXT: invoke +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 ] + unreachable + +if.end: ; preds = %invoke.cont23 + ret void +} + +; Delete a redundant retain,autorelease when forwaring a call result +; directly to a return value. + +; CHECK: define i8* @test21( +; CHECK: call i8* @returner() +; CHECK-NEXT: ret i8* %call +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: 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 +} + +; Optimize objc_retainBlock. + +; CHECK: define void @test23( +; CHECK-NOT: @objc_ +; CHECK: } +%block0 = type { i64, i64, i8*, i8* } +%block1 = type { i8**, i32, i32, i32 (%struct.__block_literal_1*)*, %block0* } +%struct.__block_descriptor = type { i64, i64 } +%struct.__block_literal_1 = type { i8**, i32, i32, i8**, %struct.__block_descriptor* } +@__block_holder_tmp_1 = external constant %block1 +define void @test23() { +entry: + %0 = call i8* @objc_retainBlock(i8* bitcast (%block1* @__block_holder_tmp_1 to i8*)) nounwind + call void @bar(i32 ()* bitcast (%block1* @__block_holder_tmp_1 to i32 ()*)) + call void @bar(i32 ()* bitcast (%block1* @__block_holder_tmp_1 to i32 ()*)) + call void @objc_release(i8* bitcast (%block1* @__block_holder_tmp_1 to i8*)) nounwind + ret void +} + +; Don't optimize objc_retainBlock. + +; CHECK: define void @test23b +; CHECK: @objc_retainBlock +; CHECK: @objc_release +; CHECK: } +define void @test23b(i8* %p) { +entry: + %0 = call i8* @objc_retainBlock(i8* %p) nounwind + call void @use_pointer(i8* %p) + call void @use_pointer(i8* %p) + call void @objc_release(i8* %p) nounwind + ret void +} + +; Any call can decrement a retain count. + +; CHECK: 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* %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: 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: 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: 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: 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: 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: 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) nounwind, !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: 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: 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: 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: 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* %g, i64 0 + call void @objc_release(i8* %g) + ret void +} + +; Do consider icmps to be direct uses. + +; CHECK: 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* %g, i64 0 + call void @objc_release(i8* %g) + ret void +} + +; Delete retain,release if there's just a possible dec. + +; CHECK: define void @test34( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test34(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* %g, i64 0 + call void @objc_release(i8* %g) + ret void +} + +; Delete retain,release if there's just a use. + +; CHECK: define void @test35( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test35(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* %g, i64 0 + call void @objc_release(i8* %g) + ret void +} + +; Delete a retain,release if there's no actual use. + +; CHECK: define void @test36( +; CHECK-NOT: @objc_ +; CHECK: call void @callee() +; CHECK-NOT: @objc_ +; CHECK: call void @callee() +; CHECK-NOT: @objc_ +; CHECK: } +define void @test36(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: define void @test37( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test37(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: 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: 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: 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: 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: 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: 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: 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) + ret void +} + +; Don't the known-incremented retain+release elimination if the pointer is +; autoreleased and there's an autoreleasePoolPop. + +; CHECK: 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: 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 void @objc_autoreleasePoolPush() +; 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 void @objc_autoreleasePoolPush() + call void @objc_release(i8* %p) + ret void +} + +; Do retain+release elimination for non-provenance pointers. + +; CHECK: define void @test44( +; CHECK-NOT: objc_ +; CHECK: } +define void @test44(i8** %pp) { + %p = load 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: 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) +define void @test45(i8** %pp, i8** %qq) { + %p = load i8** %pp + %q = load 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: define void @test46( +; CHECK: tail call i8* @objc_retain(i8* %p) nounwind +; CHECK: true: +; CHECK: tail call i8* @objc_autorelease(i8* %p) nounwind +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: define i8* @test47( +; CHECK-NOT: call +; CHECK: ret i8* %p +define i8* @test47(i8* %p) nounwind { + %x = call i8* @objc_retainedObject(i8* %p) + ret i8* %x +} + +; Delete no-op cast calls. + +; CHECK: define i8* @test48( +; CHECK-NOT: call +; CHECK: ret i8* %p +define i8* @test48(i8* %p) nounwind { + %x = call i8* @objc_unretainedObject(i8* %p) + ret i8* %x +} + +; Delete no-op cast calls. + +; CHECK: define i8* @test49( +; CHECK-NOT: call +; CHECK: ret i8* %p +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; + +; CHECK: define void @test50( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test50(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 +} + +; Don't delete retain+release with intervening stores through the +; address value. + +; CHECK: define void @test51( +; CHECK: call i8* @objc_retain(i8* %p) +; CHECK: call void @objc_release(i8* %p) +define void @test51(i8* %p) { + call i8* @objc_retain(i8* %p) + call void @callee() + store i8 0, i8* %p + call void @objc_release(i8* %p) + ret void +} + +; Don't delete retain+release with intervening use of a pointer of +; unknown provenance. + +; CHECK: define void @test52( +; CHECK: call i8* @objc_retain +; CHECK: call void @callee() +; CHECK: call void @use_pointer(i8* %z) +; CHECK: call void @objc_release +define void @test52(i8** %zz, i8** %pp) { + %p = load i8** %pp + %1 = call i8* @objc_retain(i8* %p) + call void @callee() + %z = load i8** %zz + call void @use_pointer(i8* %z) + call void @objc_release(i8* %p) + ret void +} + +; Like test52, but the pointer has function type, so it's assumed to +; be not reference counted. + +; CHECK: define void @test53( +; CHECK-NOT: @objc_ +; CHECK: } +define void @test53(void ()** %zz, i8** %pp) { + %p = load i8** %pp + %1 = call i8* @objc_retain(i8* %p) + call void @callee() + %z = load 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: define void @test54( +; CHECK: call i8* @returner() +; CHECK-NEXT: call void @objc_release(i8* %t) nounwind, !clang.imprecise_release !0 +; CHECK-NEXT: ret void +define void @test54() { + %t = call i8* @returner() + call i8* @objc_autorelease(i8* %t) + ret void +} + +; Nested retain+release pairs. Delete them both. + +; CHECK: 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: define void @test56( +; CHECK-NOT: @objc +; CHECK: if.then: +; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) nounwind +; 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) nounwind, !clang.imprecise_release !0 +; 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 +} + +declare void @bar(i32 ()*) + +; 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: @"\01-[A z]" +; 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 !0) + tail call void @llvm.dbg.value(metadata !{{}* %self}, i64 0, metadata !0) + %ivar = load i64* @"OBJC_IVAR_$_A.myZ", align 8 + %add.ptr = getelementptr i8* %0, i64 %ivar + %tmp1 = bitcast i8* %add.ptr to float* + %tmp2 = load float* %tmp1, align 4 + %conv = fpext float %tmp2 to double + %add.ptr.sum = add i64 %ivar, 4 + %tmp6 = getelementptr inbounds i8* %0, i64 %add.ptr.sum + %2 = bitcast i8* %tmp6 to float* + %tmp7 = load float* %2, align 4 + %conv8 = fpext float %tmp7 to double + %add.ptr.sum36 = add i64 %ivar, 8 + %tmp12 = getelementptr inbounds i8* %0, i64 %add.ptr.sum36 + %arrayidx = bitcast i8* %tmp12 to float* + %tmp13 = load float* %arrayidx, align 4 + %conv14 = fpext float %tmp13 to double + %tmp12.sum = add i64 %ivar, 12 + %arrayidx19 = getelementptr inbounds i8* %0, i64 %tmp12.sum + %3 = bitcast i8* %arrayidx19 to float* + %tmp20 = load float* %3, align 4 + %conv21 = fpext float %tmp20 to double + %call = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @.str4, i64 0, i64 0), double %conv, double %conv8, double %conv14, double %conv21) + %ivar23 = load i64* @"OBJC_IVAR_$_A.myZ", align 8 + %add.ptr24 = getelementptr i8* %0, i64 %ivar23 + %4 = bitcast i8* %add.ptr24 to i128* + %srcval = load 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]" +; 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]* @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]* @"\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]* @"\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 +; CHECK: for.body: +; CHECK-NOT: @objc_ +; CHECK: @objc_msgSend +; CHECK-NOT: @objc_ +; CHECK: for.end: +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** @"\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 +; 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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_17", align 8 + %tmp2 = load %struct.__CFString** @kUTTypePlainText, align 8 + %tmp3 = load 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** @"\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** @"\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** @"\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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8 + %tmp26 = load 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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8 + %tmp33 = load 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** @"\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** @"\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** @"\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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_38", align 8 + %tmp56 = load 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** @"\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** @"\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** @"\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** 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** @"\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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8 + %tmp90 = load 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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8 + %tmp95 = load 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** @"\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** %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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_50", align 8 + %tmp114 = load %1** @NSCocoaErrorDomain, align 8 + %tmp115 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_51", align 8 + %call117 = call %1* @truncatedString(%1* %filename.0, i64 1034) + %tmp118 = load %1** @NSFilePathErrorKey, align 8 + %tmp119 = load 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** @"\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** @"\01L_OBJC_CLASSLIST_REFERENCES_$_56", align 8 + %tmp128 = load 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** @"\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 +} + +!0 = metadata !{} diff --git a/test/Transforms/ObjCARC/cfg-hazards.ll b/test/Transforms/ObjCARC/cfg-hazards.ll new file mode 100644 index 0000000000..e3624df57b --- /dev/null +++ b/test/Transforms/ObjCARC/cfg-hazards.ll @@ -0,0 +1,86 @@ +; RUN: opt -S -objc-arc < %s | FileCheck %s +; rdar://9503416 + +; Detect loop boundaries and don't move retains and releases +; across them. + +declare void @use_pointer(i8*) +declare i8* @objc_retain(i8*) +declare void @objc_release(i8*) + +; CHECK: define void @test0( +; CHECK: call i8* @objc_retain( +; CHECK: for.body: +; CHECK-NOT: @objc +; CHECK: for.end: +; CHECK: call void @objc_release( +; CHECK: } +define void @test0(i8* %digits) { +entry: + %tmp1 = call i8* @objc_retain(i8* %digits) nounwind + call void @use_pointer(i8* %tmp1) + br label %for.body + +for.body: ; preds = %for.body, %entry + %upcDigitIndex.01 = phi i64 [ 2, %entry ], [ %inc, %for.body ] + call void @use_pointer(i8* %tmp1) + %inc = add i64 %upcDigitIndex.01, 1 + %cmp = icmp ult i64 %inc, 12 + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body + call void @objc_release(i8* %tmp1) nounwind, !clang.imprecise_release !0 + ret void +} + +; CHECK: define void @test1( +; CHECK: call i8* @objc_retain( +; CHECK: for.body: +; CHECK-NOT: @objc +; CHECK: for.end: +; CHECK: void @objc_release( +; CHECK: } +define void @test1(i8* %digits) { +entry: + %tmp1 = call i8* @objc_retain(i8* %digits) nounwind + br label %for.body + +for.body: ; preds = %for.body, %entry + %upcDigitIndex.01 = phi i64 [ 2, %entry ], [ %inc, %for.body ] + call void @use_pointer(i8* %tmp1) + call void @use_pointer(i8* %tmp1) + %inc = add i64 %upcDigitIndex.01, 1 + %cmp = icmp ult i64 %inc, 12 + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body + call void @objc_release(i8* %tmp1) nounwind, !clang.imprecise_release !0 + ret void +} + +; CHECK: define void @test2( +; CHECK: call i8* @objc_retain( +; CHECK: for.body: +; CHECK-NOT: @objc +; CHECK: for.end: +; CHECK: void @objc_release( +; CHECK: } +define void @test2(i8* %digits) { +entry: + %tmp1 = call i8* @objc_retain(i8* %digits) nounwind + br label %for.body + +for.body: ; preds = %for.body, %entry + %upcDigitIndex.01 = phi i64 [ 2, %entry ], [ %inc, %for.body ] + call void @use_pointer(i8* %tmp1) + %inc = add i64 %upcDigitIndex.01, 1 + %cmp = icmp ult i64 %inc, 12 + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body + call void @use_pointer(i8* %tmp1) + call void @objc_release(i8* %tmp1) nounwind, !clang.imprecise_release !0 + ret void +} + +!0 = metadata !{} diff --git a/test/Transforms/ObjCARC/contract-marker.ll b/test/Transforms/ObjCARC/contract-marker.ll new file mode 100644 index 0000000000..01d978a0e2 --- /dev/null +++ b/test/Transforms/ObjCARC/contract-marker.ll @@ -0,0 +1,23 @@ +; RUN: opt -S -objc-arc-contract < %s | FileCheck %s + +; CHECK: %call = tail call i32* @qux() +; CHECK-NEXT: %tcall = bitcast i32* %call to i8* +; CHECK-NEXT: call void asm sideeffect "mov\09r7, r7\09\09@ marker for objc_retainAutoreleaseReturnValue", ""() +; CHECK-NEXT: %0 = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %tcall) nounwind + +define void @foo() { +entry: + %call = tail call i32* @qux() + %tcall = bitcast i32* %call to i8* + %0 = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %tcall) nounwind + tail call void @bar(i8* %0) + ret void +} + +declare i32* @qux() +declare i8* @objc_retainAutoreleasedReturnValue(i8*) +declare void @bar(i8*) + +!clang.arc.retainAutoreleasedReturnValueMarker = !{!0} + +!0 = metadata !{metadata !"mov\09r7, r7\09\09@ marker for objc_retainAutoreleaseReturnValue"} diff --git a/test/Transforms/ObjCARC/contract-storestrong-ivar.ll b/test/Transforms/ObjCARC/contract-storestrong-ivar.ll new file mode 100644 index 0000000000..4ad78e7534 --- /dev/null +++ b/test/Transforms/ObjCARC/contract-storestrong-ivar.ll @@ -0,0 +1,31 @@ +; RUN: opt -objc-arc-contract -S < %s | FileCheck %s + +; CHECK: call void @objc_storeStrong(i8** + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" +target triple = "x86_64-apple-darwin11.0.0" + +%0 = type opaque +%1 = type opaque + +@"OBJC_IVAR_$_Controller.preferencesController" = external global i64, section "__DATA, __objc_const", align 8 + +declare i8* @objc_retain(i8*) + +declare void @objc_release(i8*) + +define hidden void @y(%0* nocapture %self, %1* %preferencesController) nounwind { +entry: + %ivar = load i64* @"OBJC_IVAR_$_Controller.preferencesController", align 8 + %tmp = bitcast %0* %self to i8* + %add.ptr = getelementptr inbounds i8* %tmp, i64 %ivar + %tmp1 = bitcast i8* %add.ptr to %1** + %tmp2 = load %1** %tmp1, align 8 + %tmp3 = bitcast %1* %preferencesController to i8* + %tmp4 = tail call i8* @objc_retain(i8* %tmp3) nounwind + %tmp5 = bitcast %1* %tmp2 to i8* + tail call void @objc_release(i8* %tmp5) nounwind + %tmp6 = bitcast i8* %tmp4 to %1* + store %1* %tmp6, %1** %tmp1, align 8 + ret void +} diff --git a/test/Transforms/ObjCARC/contract-storestrong.ll b/test/Transforms/ObjCARC/contract-storestrong.ll new file mode 100644 index 0000000000..50ed260eb0 --- /dev/null +++ b/test/Transforms/ObjCARC/contract-storestrong.ll @@ -0,0 +1,59 @@ +; RUN: opt -objc-arc-contract -S < %s | FileCheck %s + +target datalayout = "e-p:64:64:64" + +declare i8* @objc_retain(i8*) +declare void @objc_release(i8*) + +@x = external global i8* + +; CHECK: define void @test0( +; CHECK: entry: +; CHECK-NEXT: call void @objc_storeStrong(i8** @x, i8* %p) nounwind +; CHECK-NEXT: ret void +define void @test0(i8* %p) { +entry: + %0 = tail call i8* @objc_retain(i8* %p) nounwind + %tmp = load i8** @x, align 8 + store i8* %0, i8** @x, align 8 + tail call void @objc_release(i8* %tmp) nounwind + ret void +} + +; Don't do this if the load is volatile. + +; CHECK: define void @test1(i8* %p) { +; CHECK-NEXT: entry: +; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %p) nounwind +; CHECK-NEXT: %tmp = volatile load i8** @x, align 8 +; CHECK-NEXT: store i8* %0, i8** @x, align 8 +; CHECK-NEXT: tail call void @objc_release(i8* %tmp) nounwind +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test1(i8* %p) { +entry: + %0 = tail call i8* @objc_retain(i8* %p) nounwind + %tmp = volatile load i8** @x, align 8 + store i8* %0, i8** @x, align 8 + tail call void @objc_release(i8* %tmp) nounwind + ret void +} + +; Don't do this if the store is volatile. + +; CHECK: define void @test2(i8* %p) { +; CHECK-NEXT: entry: +; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %p) nounwind +; CHECK-NEXT: %tmp = load i8** @x, align 8 +; CHECK-NEXT: volatile store i8* %0, i8** @x, align 8 +; CHECK-NEXT: tail call void @objc_release(i8* %tmp) nounwind +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test2(i8* %p) { +entry: + %0 = tail call i8* @objc_retain(i8* %p) nounwind + %tmp = load i8** @x, align 8 + volatile store i8* %0, i8** @x, align 8 + tail call void @objc_release(i8* %tmp) nounwind + ret void +} diff --git a/test/Transforms/ObjCARC/contract-testcases.ll b/test/Transforms/ObjCARC/contract-testcases.ll new file mode 100644 index 0000000000..69fa837675 --- /dev/null +++ b/test/Transforms/ObjCARC/contract-testcases.ll @@ -0,0 +1,63 @@ +; RUN: opt -objc-arc-contract -S < %s | FileCheck %s +; rdar://9511608 + +%0 = type opaque +%1 = type opaque +%2 = type { i64, i64 } +%3 = type { i8*, i8* } +%4 = type opaque + +declare %0* @"\01-[NSAttributedString(Terminal) pathAtIndex:effectiveRange:]"(%1*, i8* nocapture, i64, %2*) optsize +declare i8* @objc_retainAutoreleasedReturnValue(i8*) +declare i8* @objc_msgSend_fixup(i8*, %3*, ...) +declare void @objc_release(i8*) +declare %2 @NSUnionRange(i64, i64, i64, i64) optsize +declare i8* @objc_autoreleaseReturnValue(i8*) +declare i8* @objc_autorelease(i8*) +declare i8* @objc_msgSend() nonlazybind + +; Don't get in trouble on bugpointed code. + +; CHECK: define void @test0( +define void @test0() { +bb: + %tmp = bitcast %4* undef to i8* + %tmp1 = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %tmp) nounwind + br label %bb3 + +bb3: ; preds = %bb2 + br i1 undef, label %bb6, label %bb4 + +bb4: ; preds = %bb3 + switch i64 undef, label %bb5 [ + i64 9223372036854775807, label %bb6 + i64 0, label %bb6 + ] + +bb5: ; preds = %bb4 + br label %bb6 + +bb6: ; preds = %bb5, %bb4, %bb4, %bb3 + %tmp7 = phi %4* [ undef, %bb5 ], [ undef, %bb4 ], [ undef, %bb3 ], [ undef, %bb4 ] + unreachable +} + +; When rewriting operands for a phi which has multiple operands +; for the same block, use the exactly same value in each block. + +; CHECK: define void @test1( +; CHECK: %0 = bitcast i8* %tmp3 to %0* +; CHECK: br i1 undef, label %bb7, label %bb7 +; CHECK: bb7: +; CHECK: %tmp8 = phi %0* [ %0, %bb ], [ %0, %bb ] +define void @test1() { +bb: + %tmp = tail call %0* bitcast (i8* ()* @objc_msgSend to %0* ()*)() + %tmp2 = bitcast %0* %tmp to i8* + %tmp3 = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %tmp2) nounwind + br i1 undef, label %bb7, label %bb7 + +bb7: ; preds = %bb6, %bb6, %bb5 + %tmp8 = phi %0* [ %tmp, %bb ], [ %tmp, %bb ] + unreachable +} diff --git a/test/Transforms/ObjCARC/contract.ll b/test/Transforms/ObjCARC/contract.ll new file mode 100644 index 0000000000..04ae3ca505 --- /dev/null +++ b/test/Transforms/ObjCARC/contract.ll @@ -0,0 +1,145 @@ +; RUN: opt -objc-arc-contract -S < %s | FileCheck %s + +target datalayout = "e-p:64:64:64" + +declare i8* @objc_retain(i8*) +declare void @objc_release(i8*) +declare i8* @objc_autorelease(i8*) +declare i8* @objc_autoreleaseReturnValue(i8*) +declare i8* @objc_retainAutoreleasedReturnValue(i8*) + +declare void @use_pointer(i8*) +declare i8* @returner() + +; CHECK: define void @test0 +; CHECK: call void @use_pointer(i8* %0) +; CHECK: } +define void @test0(i8* %x) nounwind { +entry: + %0 = call i8* @objc_retain(i8* %x) nounwind + call void @use_pointer(i8* %x) + ret void +} + +; CHECK: define void @test1 +; CHECK: call void @use_pointer(i8* %0) +; CHECK: } +define void @test1(i8* %x) nounwind { +entry: + %0 = call i8* @objc_autorelease(i8* %x) nounwind + call void @use_pointer(i8* %x) + ret void +} + +; Merge objc_retain and objc_autorelease into objc_retainAutorelease. + +; CHECK: define void @test2( +; CHECK: tail call i8* @objc_retainAutorelease(i8* %x) nounwind +; CHECK: } +define void @test2(i8* %x) nounwind { +entry: + %0 = tail call i8* @objc_retain(i8* %x) nounwind + tail call i8* @objc_autorelease(i8* %0) nounwind + call void @use_pointer(i8* %x) + ret void +} + +; Same as test2 but the value is returned. Do an RV optimization. + +; CHECK: define i8* @test2b( +; CHECK: tail call i8* @objc_retainAutoreleaseReturnValue(i8* %x) nounwind +; CHECK: } +define i8* @test2b(i8* %x) nounwind { +entry: + %0 = tail call i8* @objc_retain(i8* %x) nounwind + tail call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind + ret i8* %x +} + +; Merge a retain,autorelease pair around a call. + +; CHECK: define void @test3( +; CHECK: tail call i8* @objc_retainAutorelease(i8* %x) nounwind +; CHECK: @use_pointer(i8* %0) +; CHECK: } +define void @test3(i8* %x, i64 %n) { +entry: + tail call i8* @objc_retain(i8* %x) nounwind + call void @use_pointer(i8* %x) + tail call i8* @objc_autorelease(i8* %x) nounwind + ret void +} + +; Trivial retain,autorelease pair with intervening call, but it's post-dominated +; by another release. The retain and autorelease can be merged. + +; CHECK: define void @test4( +; CHECK-NEXT: entry: +; CHECK-NEXT: @objc_retainAutorelease(i8* %x) nounwind +; CHECK-NEXT: @use_pointer +; CHECK-NEXT: @objc_release +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test4(i8* %x, i64 %n) { +entry: + tail call i8* @objc_retain(i8* %x) nounwind + call void @use_pointer(i8* %x) + tail call i8* @objc_autorelease(i8* %x) nounwind + tail call void @objc_release(i8* %x) nounwind + ret void +} + +; Don't merge retain and autorelease if they're not control-equivalent. + +; CHECK: define void @test5( +; CHECK: tail call i8* @objc_retain(i8* %p) nounwind +; CHECK: true: +; CHECK: tail call i8* @objc_autorelease(i8* %0) nounwind +; CHECK: } +define void @test5(i8* %p, i1 %a) { +entry: + tail call i8* @objc_retain(i8* %p) nounwind + br i1 %a, label %true, label %false + +true: + tail call i8* @objc_autorelease(i8* %p) nounwind + call void @use_pointer(i8* %p) + ret void + +false: + ret void +} + +; Don't eliminate objc_retainAutoreleasedReturnValue by merging it into +; an objc_autorelease. +; TODO? Merge objc_retainAutoreleasedReturnValue and objc_autorelease into +; objc_retainAutoreleasedReturnValueAutorelease and merge +; objc_retainAutoreleasedReturnValue and objc_autoreleaseReturnValue +; into objc_retainAutoreleasedReturnValueAutoreleaseReturnValue? +; Those entrypoints don't exist yet though. + +; CHECK: define i8* @test6( +; CHECK: call i8* @objc_retainAutoreleasedReturnValue(i8* %p) nounwind +; CHECK: %t = tail call i8* @objc_autoreleaseReturnValue(i8* %1) nounwind +; CHECK: } +define i8* @test6() { + %p = call i8* @returner() + tail call i8* @objc_retainAutoreleasedReturnValue(i8* %p) nounwind + %t = tail call i8* @objc_autoreleaseReturnValue(i8* %p) nounwind + call void @use_pointer(i8* %t) + ret i8* %t +} + +; Don't spoil the RV optimization. + +; CHECK: define i8* @test7(i8* %p) +; CHECK: tail call i8* @objc_retain(i8* %p) +; CHECK: call void @use_pointer(i8* %1) +; CHECK: tail call i8* @objc_autoreleaseReturnValue(i8* %1) +; CHECK: ret i8* %2 +define i8* @test7(i8* %p) { + %1 = tail call i8* @objc_retain(i8* %p) + call void @use_pointer(i8* %p) + %2 = tail call i8* @objc_autoreleaseReturnValue(i8* %p) + ret i8* %p +} diff --git a/test/Transforms/ObjCARC/dg.exp b/test/Transforms/ObjCARC/dg.exp new file mode 100644 index 0000000000..f2005891a5 --- /dev/null +++ b/test/Transforms/ObjCARC/dg.exp @@ -0,0 +1,3 @@ +load_lib llvm.exp + +RunLLVMTests [lsort [glob -nocomplain $srcdir/$subdir/*.{ll,c,cpp}]] diff --git a/test/Transforms/ObjCARC/expand.ll b/test/Transforms/ObjCARC/expand.ll new file mode 100644 index 0000000000..5388673f2b --- /dev/null +++ b/test/Transforms/ObjCARC/expand.ll @@ -0,0 +1,28 @@ +; RUN: opt -objc-arc-expand -S < %s | FileCheck %s + +target datalayout = "e-p:64:64:64" + +declare i8* @objc_retain(i8*) +declare i8* @objc_autorelease(i8*) + +declare void @use_pointer(i8*) + +; CHECK: define void @test0 +; CHECK: call void @use_pointer(i8* %x) +; CHECK: } +define void @test0(i8* %x) nounwind { +entry: + %0 = call i8* @objc_retain(i8* %x) nounwind + call void @use_pointer(i8* %0) + ret void +} + +; CHECK: define void @test1 +; CHECK: call void @use_pointer(i8* %x) +; CHECK: } +define void @test1(i8* %x) nounwind { +entry: + %0 = call i8* @objc_autorelease(i8* %x) nounwind + call void @use_pointer(i8* %x) + ret void +} diff --git a/test/Transforms/ObjCARC/gvn.ll b/test/Transforms/ObjCARC/gvn.ll new file mode 100644 index 0000000000..6917b02e03 --- /dev/null +++ b/test/Transforms/ObjCARC/gvn.ll @@ -0,0 +1,21 @@ +; RUN: opt -S -basicaa -objc-arc -gvn < %s | FileCheck %s + +@x = common global i8* null, align 8 + +declare i8* @objc_retain(i8*) + +; GVN should be able to eliminate this redundant load, with ARC-specific +; alias analysis. + +; CHECK: @foo +; CHECK-NEXT: entry: +; CHECK-NEXT: %s = load i8** @x +; CHECK-NOT: load +; CHECK: ret i8* %s +define i8* @foo(i32 %n) nounwind { +entry: + %s = load i8** @x + %0 = tail call i8* @objc_retain(i8* %s) nounwind + %t = load i8** @x + ret i8* %s +} diff --git a/test/Transforms/ObjCARC/move-and-form-retain-autorelease.ll b/test/Transforms/ObjCARC/move-and-form-retain-autorelease.ll new file mode 100644 index 0000000000..170d0a99c9 --- /dev/null +++ b/test/Transforms/ObjCARC/move-and-form-retain-autorelease.ll @@ -0,0 +1,221 @@ +; RUN: opt -S -objc-arc-contract < %s | FileCheck %s + +; The optimizer should be able to move the autorelease past a control triangle +; and various scary looking things and fold it into an objc_retainAutorelease. + +; CHECK: bb57: +; CHECK: tail call i8* @objc_retainAutorelease(i8* %tmp71x) nounwind +; CHECK: bb99: + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" +target triple = "x86_64-apple-darwin11.0.0" + +%0 = type { i8* (i8*, %1*, ...)*, i8* } +%1 = type { i8*, i8* } +%2 = type { %2*, %2*, %3*, i8* (i8*, i8*)**, %4* } +%3 = type opaque +%4 = type { i32, i32, i32, i8*, i8*, %5*, %7*, %10*, i8*, %9* } +%5 = type { i32, i32, [0 x %6] } +%6 = type { i8*, i8*, i8* } +%7 = type { i64, [0 x %8*] } +%8 = type { i8*, i8*, %7*, %5*, %5*, %5*, %5*, %9*, i32, i32 } +%9 = type { i32, i32, [0 x %1] } +%10 = type { i32, i32, [0 x %11] } +%11 = type { i64*, i8*, i8*, i32, i32 } +%12 = type { i32*, i32, i8*, i64 } +%13 = type opaque +%14 = type opaque +%15 = type opaque +%16 = type opaque +%17 = type opaque +%18 = type opaque +%19 = type opaque +%20 = type opaque +%21 = type opaque +%22 = type opaque +%23 = type opaque +%24 = type opaque +%25 = type opaque + +@"\01l_objc_msgSend_fixup_alloc" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16 +@"\01L_OBJC_SELECTOR_REFERENCES_8" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_3725" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_CLASSLIST_REFERENCES_$_40" = external hidden global %2*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 +@"\01L_OBJC_SELECTOR_REFERENCES_4227" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_4631" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_CLASSLIST_REFERENCES_$_70" = external hidden global %2*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 +@"\01L_OBJC_SELECTOR_REFERENCES_148" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_159" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_188" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_328" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01l_objc_msgSend_fixup_objectAtIndex_" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16 +@_unnamed_cfstring_386 = external hidden constant %12, section "__DATA,__cfstring" +@"\01l_objc_msgSend_fixup_count" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16 +@"\01L_OBJC_SELECTOR_REFERENCES_389" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_391" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_393" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@NSPrintHeaderAndFooter = external constant %13* +@"\01L_OBJC_SELECTOR_REFERENCES_395" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_CLASSLIST_REFERENCES_$_396" = external hidden global %2*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 +@"\01L_OBJC_SELECTOR_REFERENCES_398" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_400" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_402" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_404" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_406" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_408" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_CLASSLIST_REFERENCES_$_409" = external hidden global %2*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 +@"\01L_OBJC_SELECTOR_REFERENCES_411" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_413" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_415" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" + +declare i8* @objc_msgSend(i8*, i8*, ...) + +declare i8* @objc_retain(i8*) + +declare void @objc_release(i8*) + +declare i8* @objc_autorelease(i8*) + +declare i8* @objc_explicit_autorelease(i8*) + +define hidden %14* @foo(%15* %arg, %16* %arg2) { +bb: + %tmp = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_3725", align 8 + %tmp4 = bitcast %15* %arg to i8* + %tmp5 = tail call %18* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %18* (i8*, i8*)*)(i8* %tmp4, i8* %tmp) + %tmp6 = bitcast %18* %tmp5 to i8* + %tmp7 = tail call i8* @objc_retain(i8* %tmp6) nounwind + %tmp8 = load %2** @"\01L_OBJC_CLASSLIST_REFERENCES_$_40", align 8 + %tmp9 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_4227", align 8 + %tmp10 = bitcast %2* %tmp8 to i8* + %tmp11 = tail call %19* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %19* (i8*, i8*)*)(i8* %tmp10, i8* %tmp9) + %tmp12 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_4631", align 8 + %tmp13 = bitcast %19* %tmp11 to i8* + %tmp14 = tail call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*, %13*)*)(i8* %tmp13, i8* %tmp12, %13* bitcast (%12* @_unnamed_cfstring_386 to %13*)) + %tmp15 = bitcast %16* %arg2 to i8* + %tmp16 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_count" to i8**), align 16 + %tmp17 = bitcast i8* %tmp16 to i64 (i8*, %1*)* + %tmp18 = tail call i64 %tmp17(i8* %tmp15, %1* bitcast (%0* @"\01l_objc_msgSend_fixup_count" to %1*)) + %tmp19 = icmp eq i64 %tmp18, 0 + br i1 %tmp19, label %bb22, label %bb20 + +bb20: ; preds = %bb + %tmp21 = icmp eq i8 %tmp14, 0 + br label %bb25 + +bb22: ; preds = %bb + %tmp23 = bitcast i8* %tmp7 to %18* + %tmp24 = icmp eq i8 %tmp14, 0 + br i1 %tmp24, label %bb46, label %bb25 + +bb25: ; preds = %bb22, %bb20 + %tmp26 = phi i1 [ %tmp21, %bb20 ], [ false, %bb22 ] + %tmp27 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_188", align 8 + %tmp28 = tail call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %tmp7, i8* %tmp27) + %tmp29 = tail call i8* @objc_explicit_autorelease(i8* %tmp28) nounwind + %tmp30 = bitcast i8* %tmp29 to %18* + tail call void @objc_release(i8* %tmp7) nounwind + %tmp31 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_389", align 8 + %tmp32 = tail call %20* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %20* (i8*, i8*)*)(i8* %tmp29, i8* %tmp31) + %tmp33 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_391", align 8 + %tmp34 = bitcast %20* %tmp32 to i8* + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, %16*)*)(i8* %tmp34, i8* %tmp33, %16* %arg2) + br i1 %tmp26, label %bb46, label %bb35 + +bb35: ; preds = %bb25 + %tmp36 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_389", align 8 + %tmp37 = tail call %20* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %20* (i8*, i8*)*)(i8* %tmp29, i8* %tmp36) + %tmp38 = load %2** @"\01L_OBJC_CLASSLIST_REFERENCES_$_70", align 8 + %tmp39 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_393", align 8 + %tmp40 = bitcast %2* %tmp38 to i8* + %tmp41 = tail call %21* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %21* (i8*, i8*, i8)*)(i8* %tmp40, i8* %tmp39, i8 signext 1) + %tmp42 = bitcast %21* %tmp41 to i8* + %tmp43 = load %13** @NSPrintHeaderAndFooter, align 8 + %tmp44 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_159", align 8 + %tmp45 = bitcast %20* %tmp37 to i8* + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, %13*)*)(i8* %tmp45, i8* %tmp44, i8* %tmp42, %13* %tmp43) + br label %bb46 + +bb46: ; preds = %bb35, %bb25, %bb22 + %tmp47 = phi %18* [ %tmp30, %bb35 ], [ %tmp30, %bb25 ], [ %tmp23, %bb22 ] + %tmp48 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_328", align 8 + %tmp49 = tail call %22* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %22* (i8*, i8*)*)(i8* %tmp4, i8* %tmp48) + %tmp50 = bitcast %22* %tmp49 to i8* + %tmp51 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_count" to i8**), align 16 + %tmp52 = bitcast i8* %tmp51 to i64 (i8*, %1*)* + %tmp53 = tail call i64 %tmp52(i8* %tmp50, %1* bitcast (%0* @"\01l_objc_msgSend_fixup_count" to %1*)) + %tmp54 = icmp eq i64 %tmp53, 0 + br i1 %tmp54, label %bb55, label %bb57 + +bb55: ; preds = %bb46 + %tmp56 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_395", align 8 + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %tmp4, i8* %tmp56) + br label %bb57 + +bb57: ; preds = %bb55, %bb46 + %tmp58 = load %2** @"\01L_OBJC_CLASSLIST_REFERENCES_$_396", align 8 + %tmp59 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_328", align 8 + %tmp60 = tail call %22* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %22* (i8*, i8*)*)(i8* %tmp4, i8* %tmp59) + %tmp61 = bitcast %22* %tmp60 to i8* + %tmp62 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_objectAtIndex_" to i8**), align 16 + %tmp63 = bitcast i8* %tmp62 to i8* (i8*, %1*, i64)* + %tmp64 = tail call i8* %tmp63(i8* %tmp61, %1* bitcast (%0* @"\01l_objc_msgSend_fixup_objectAtIndex_" to %1*), i64 0) + %tmp65 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_398", align 8 + %tmp66 = tail call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %tmp64, i8* %tmp65) + %tmp67 = bitcast i8* %tmp66 to %23* + %tmp68 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_400", align 8 + %tmp69 = bitcast %2* %tmp58 to i8* + %tmp70 = tail call %14* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %14* (i8*, i8*, %23*, %18*)*)(i8* %tmp69, i8* %tmp68, %23* %tmp67, %18* %tmp47) + %tmp71 = bitcast %14* %tmp70 to i8* + ; hack to prevent the optimize from using objc_retainAutoreleasedReturnValue. + %tmp71x = getelementptr i8* %tmp71, i64 1 + %tmp72 = tail call i8* @objc_retain(i8* %tmp71x) nounwind + %tmp73 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_402", align 8 + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8)*)(i8* %tmp72, i8* %tmp73, i8 signext 1) + %tmp74 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_404", align 8 + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8)*)(i8* %tmp72, i8* %tmp74, i8 signext 1) + %tmp75 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_328", align 8 + %tmp76 = tail call %22* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %22* (i8*, i8*)*)(i8* %tmp4, i8* %tmp75) + %tmp77 = bitcast %22* %tmp76 to i8* + %tmp78 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_objectAtIndex_" to i8**), align 16 + %tmp79 = bitcast i8* %tmp78 to i8* (i8*, %1*, i64)* + %tmp80 = tail call i8* %tmp79(i8* %tmp77, %1* bitcast (%0* @"\01l_objc_msgSend_fixup_objectAtIndex_" to %1*), i64 0) + %tmp81 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_406", align 8 + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i64)*)(i8* %tmp80, i8* %tmp81, i64 9223372036854775807) + %tmp82 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_408", align 8 + %tmp83 = tail call %24* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %24* (i8*, i8*)*)(i8* %tmp72, i8* %tmp82) + %tmp84 = bitcast %24* %tmp83 to i8* + %tmp85 = tail call i8* @objc_retain(i8* %tmp84) nounwind + %tmp86 = load %2** @"\01L_OBJC_CLASSLIST_REFERENCES_$_409", align 8 + %tmp87 = bitcast %2* %tmp86 to i8* + %tmp88 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_alloc" to i8**), align 16 + %tmp89 = bitcast i8* %tmp88 to i8* (i8*, %1*)* + %tmp90 = tail call i8* %tmp89(i8* %tmp87, %1* bitcast (%0* @"\01l_objc_msgSend_fixup_alloc" to %1*)) + %tmp91 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_8", align 8 + %tmp92 = tail call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %tmp90, i8* %tmp91) + %tmp93 = tail call i8* @objc_explicit_autorelease(i8* %tmp92) nounwind + %tmp94 = bitcast i8* %tmp93 to %25* + %tmp95 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_411", align 8 + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, %25*)*)(i8* %tmp85, i8* %tmp95, %25* %tmp94) + tail call void @objc_release(i8* %tmp93) nounwind + %tmp96 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_148", align 8 + %tmp97 = tail call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %tmp4, i8* %tmp96) + %tmp98 = icmp eq i8 %tmp97, 0 + br i1 %tmp98, label %bb99, label %bb104 + +bb99: ; preds = %bb57 + %tmp100 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_413", align 8 + %tmp101 = tail call i64 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i64 (i8*, i8*)*)(i8* %tmp85, i8* %tmp100) + %tmp102 = or i64 %tmp101, 12 + %tmp103 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_415", align 8 + tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i64)*)(i8* %tmp85, i8* %tmp103, i64 %tmp102) + br label %bb104 + +bb104: ; preds = %bb99, %bb57 + %tmp105 = tail call i8* @objc_autorelease(i8* %tmp72) nounwind + %tmp106 = bitcast i8* %tmp105 to %14* + tail call void @objc_release(i8* %tmp85) nounwind + %tmp107 = bitcast %18* %tmp47 to i8* + tail call void @objc_release(i8* %tmp107) nounwind + ret %14* %tmp106 +} diff --git a/test/Transforms/ObjCARC/move-and-merge-autorelease.ll b/test/Transforms/ObjCARC/move-and-merge-autorelease.ll new file mode 100644 index 0000000000..8462c70a48 --- /dev/null +++ b/test/Transforms/ObjCARC/move-and-merge-autorelease.ll @@ -0,0 +1,108 @@ +; RUN: opt -S -objc-arc < %s | FileCheck %s + +; The optimizer should be able to move the autorelease past two phi nodes +; and fold it with the release in bb65. + +; CHECK: bb65: +; CHECK: call i8* @objc_retainAutorelease +; CHECK: br label %bb76 + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" +target triple = "x86_64-apple-darwin11.0.0" + +%0 = type opaque +%1 = type opaque +%2 = type opaque +%3 = type opaque +%4 = type opaque +%5 = type opaque + +@"\01L_OBJC_SELECTOR_REFERENCES_11" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_421455" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_598" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_620" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_622" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_624" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +@"\01L_OBJC_SELECTOR_REFERENCES_626" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" + +declare i8* @objc_msgSend(i8*, i8*, ...) + +declare i8* @objc_retain(i8*) + +declare void @objc_release(i8*) + +declare i8* @objc_autorelease(i8*) + +define hidden %0* @foo(%1* %arg, %3* %arg3) { +bb: + %tmp16 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_620", align 8 + %tmp17 = bitcast %3* %arg3 to i8* + %tmp18 = call %4* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %4* (i8*, i8*)*)(i8* %tmp17, i8* %tmp16) + %tmp19 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_622", align 8 + %tmp20 = bitcast %4* %tmp18 to i8* + %tmp21 = call %5* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %5* (i8*, i8*)*)(i8* %tmp20, i8* %tmp19) + %tmp22 = bitcast %5* %tmp21 to i8* + %tmp23 = call i8* @objc_retain(i8* %tmp22) nounwind + %tmp24 = bitcast i8* %tmp23 to %5* + %tmp26 = icmp eq i8* %tmp23, null + br i1 %tmp26, label %bb81, label %bb27 + +bb27: ; preds = %bb + %tmp29 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_11", align 8 + %tmp30 = bitcast %1* %arg to i8* + %tmp31 = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %tmp30, i8* %tmp29) + %tmp34 = call i8* @objc_retain(i8* %tmp31) nounwind + %tmp37 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_421455", align 8 + %tmp39 = call %0* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %0* (i8*, i8*)*)(i8* %tmp34, i8* %tmp37) + %tmp40 = bitcast %0* %tmp39 to i8* + %tmp41 = call i8* @objc_retain(i8* %tmp40) nounwind + %tmp42 = bitcast i8* %tmp41 to %0* + %tmp44 = icmp eq i8* %tmp41, null + br i1 %tmp44, label %bb45, label %bb55 + +bb45: ; preds = %bb27 + %tmp47 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_624", align 8 + %tmp49 = call %0* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %0* (i8*, i8*)*)(i8* %tmp34, i8* %tmp47) + %tmp51 = bitcast %0* %tmp49 to i8* + %tmp52 = call i8* @objc_retain(i8* %tmp51) nounwind + call void @objc_release(i8* %tmp41) nounwind + br label %bb55 + +bb55: ; preds = %bb27, %bb45 + %tmp13.0 = phi %0* [ %tmp42, %bb27 ], [ %tmp49, %bb45 ] + %tmp57 = icmp eq %0* %tmp13.0, null + br i1 %tmp57, label %bb76, label %bb58 + +bb58: ; preds = %bb55 + %tmp60 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_598", align 8 + %tmp61 = bitcast %0* %tmp13.0 to i8* + %tmp62 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %tmp61, i8* %tmp60) + %tmp64 = icmp eq i8 %tmp62, 0 + br i1 %tmp64, label %bb76, label %bb65 + +bb65: ; preds = %bb58 + %tmp68 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_626", align 8 + %tmp69 = bitcast %0* %tmp13.0 to i8* + %tmp70 = call %0* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %0* (i8*, i8*, %5*)*)(i8* %tmp69, i8* %tmp68, %5* %tmp24) + %tmp72 = bitcast %0* %tmp70 to i8* + %tmp73 = call i8* @objc_retain(i8* %tmp72) nounwind + br label %bb76 + +bb76: ; preds = %bb58, %bb55, %bb65 + %tmp10.0 = phi %0* [ %tmp70, %bb65 ], [ null, %bb58 ], [ null, %bb55 ] + %tmp78 = bitcast %0* %tmp13.0 to i8* + call void @objc_release(i8* %tmp78) nounwind + call void @objc_release(i8* %tmp34) nounwind + br label %bb81 + +bb81: ; preds = %bb, %bb76 + %tmp10.1 = phi %0* [ %tmp10.0, %bb76 ], [ null, %bb ] + %tmp83 = bitcast %0* %tmp10.1 to i8* + %tmp84 = call i8* @objc_retain(i8* %tmp83) nounwind + %tmp88 = bitcast i8* %tmp87 to %0* + call void @objc_release(i8* %tmp23) nounwind + %tmp87 = call i8* @objc_autorelease(i8* %tmp84) nounwind + %tmp92 = bitcast %0* %tmp10.1 to i8* + call void @objc_release(i8* %tmp92) nounwind + ret %0* %tmp88 +} diff --git a/test/Transforms/ObjCARC/post-inlining.ll b/test/Transforms/ObjCARC/post-inlining.ll new file mode 100644 index 0000000000..ad69ccdd79 --- /dev/null +++ b/test/Transforms/ObjCARC/post-inlining.ll @@ -0,0 +1,48 @@ +; RUN: opt -S -objc-arc < %s | FileCheck %s + +declare void @use_pointer(i8*) +declare i8* @returner() +declare i8* @objc_retain(i8*) +declare i8* @objc_autoreleaseReturnValue(i8*) +declare i8* @objc_retainAutoreleasedReturnValue(i8*) + +; Clean up residue left behind after inlining. + +; CHECK: define void @test0( +; CHECK: entry: +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test0(i8* %call.i) { +entry: + %0 = tail call i8* @objc_retain(i8* %call.i) nounwind + %1 = tail call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind + ret void +} + +; Same as test0, but with slightly different use arrangements. + +; CHECK: define void @test1( +; CHECK: entry: +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test1(i8* %call.i) { +entry: + %0 = tail call i8* @objc_retain(i8* %call.i) nounwind + %1 = tail call i8* @objc_autoreleaseReturnValue(i8* %call.i) nounwind + ret void +} + +; Delete a retainRV+autoreleaseRV even if the pointer is used. + +; CHECK: define void @test24( +; CHECK-NEXT: entry: +; CHECK-NEXT: call void @use_pointer(i8* %p) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test24(i8* %p) { +entry: + call i8* @objc_autoreleaseReturnValue(i8* %p) nounwind + call i8* @objc_retainAutoreleasedReturnValue(i8* %p) nounwind + call void @use_pointer(i8* %p) + ret void +} diff --git a/test/Transforms/ObjCARC/retain-not-declared.ll b/test/Transforms/ObjCARC/retain-not-declared.ll new file mode 100644 index 0000000000..e1fe117063 --- /dev/null +++ b/test/Transforms/ObjCARC/retain-not-declared.ll @@ -0,0 +1,25 @@ +; RUN: opt -S -objc-arc -objc-arc-contract < %s | FileCheck %s + +; Test that the optimizer can create an objc_retainAutoreleaseReturnValue +; declaration even if no objc_retain declaration exists. +; rdar://9401303 + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" +declare i8* @objc_unretainedObject(i8*) +declare i8* @objc_retainAutoreleasedReturnValue(i8*) +declare i8* @objc_autoreleaseReturnValue(i8*) + +; CHECK: define i8* @foo(i8* %p) { +; CHECK-NEXT: entry: +; CHECK-NEXT: %0 = tail call i8* @objc_retainAutoreleaseReturnValue(i8* %p) nounwind +; CHECK-NEXT: ret i8* %0 +; CHECK-NEXT: } + +define i8* @foo(i8* %p) { +entry: + %call = tail call i8* @objc_unretainedObject(i8* %p) + %0 = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %call) nounwind + %1 = tail call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind + ret i8* %1 +} + diff --git a/test/Transforms/ObjCARC/rle-s2l.ll b/test/Transforms/ObjCARC/rle-s2l.ll new file mode 100644 index 0000000000..8f8d5c0d38 --- /dev/null +++ b/test/Transforms/ObjCARC/rle-s2l.ll @@ -0,0 +1,135 @@ +; RUN: opt -S -basicaa -objc-arc < %s | FileCheck %s + +declare i8* @objc_loadWeak(i8**) +declare i8* @objc_loadWeakRetained(i8**) +declare i8* @objc_storeWeak(i8**, i8*) +declare i8* @objc_initWeak(i8**, i8*) +declare void @use_pointer(i8*) +declare void @callee() + +; Basic redundant @objc_loadWeak elimination. + +; CHECK: define void @test0(i8** %p) { +; CHECK-NEXT: %y = call i8* @objc_loadWeak(i8** %p) +; CHECK-NEXT: call void @use_pointer(i8* %y) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test0(i8** %p) { + %x = call i8* @objc_loadWeak(i8** %p) + %y = call i8* @objc_loadWeak(i8** %p) + call void @use_pointer(i8* %y) + ret void +} + +; DCE the @objc_loadWeak. + +; CHECK: define void @test1(i8** %p) { +; CHECK-NEXT: %y = call i8* @objc_loadWeakRetained(i8** %p) +; CHECK-NEXT: call void @use_pointer(i8* %y) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test1(i8** %p) { + %x = call i8* @objc_loadWeak(i8** %p) + %y = call i8* @objc_loadWeakRetained(i8** %p) + call void @use_pointer(i8* %y) + ret void +} + +; Basic redundant @objc_loadWeakRetained elimination. + +; CHECK: define void @test2(i8** %p) { +; CHECK-NEXT: %x = call i8* @objc_loadWeak(i8** %p) +; CHECK-NEXT: store i8 3, i8* %x +; CHECK-NEXT: %1 = tail call i8* @objc_retain(i8* %x) +; CHECK-NEXT: call void @use_pointer(i8* %x) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test2(i8** %p) { + %x = call i8* @objc_loadWeak(i8** %p) + store i8 3, i8* %x + %y = call i8* @objc_loadWeakRetained(i8** %p) + call void @use_pointer(i8* %y) + ret void +} + +; Basic redundant @objc_loadWeakRetained elimination, this time +; with a readonly call instead of a store. + +; CHECK: define void @test3(i8** %p) { +; CHECK-NEXT: %x = call i8* @objc_loadWeak(i8** %p) +; CHECK-NEXT: call void @use_pointer(i8* %x) readonly +; CHECK-NEXT: %1 = tail call i8* @objc_retain(i8* %x) +; CHECK-NEXT: call void @use_pointer(i8* %x) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test3(i8** %p) { + %x = call i8* @objc_loadWeak(i8** %p) + call void @use_pointer(i8* %x) readonly + %y = call i8* @objc_loadWeakRetained(i8** %p) + call void @use_pointer(i8* %y) + ret void +} + +; A regular call blocks redundant weak load elimination. + +; CHECK: define void @test4(i8** %p) { +; CHECK-NEXT: %x = call i8* @objc_loadWeak(i8** %p) +; CHECK-NEXT: call void @use_pointer(i8* %x) readonly +; CHECK-NEXT: call void @callee() +; CHECK-NEXT: %y = call i8* @objc_loadWeak(i8** %p) +; CHECK-NEXT: call void @use_pointer(i8* %y) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test4(i8** %p) { + %x = call i8* @objc_loadWeak(i8** %p) + call void @use_pointer(i8* %x) readonly + call void @callee() + %y = call i8* @objc_loadWeak(i8** %p) + call void @use_pointer(i8* %y) + ret void +} + +; Store to load forwarding. + +; CHECK: define void @test5(i8** %p, i8* %n) { +; CHECK-NEXT: %1 = call i8* @objc_storeWeak(i8** %p, i8* %n) +; CHECK-NEXT: call void @use_pointer(i8* %n) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test5(i8** %p, i8* %n) { + call i8* @objc_storeWeak(i8** %p, i8* %n) + %y = call i8* @objc_loadWeak(i8** %p) + call void @use_pointer(i8* %y) + ret void +} + +; Store to load forwarding with objc_initWeak. + +; CHECK: define void @test6(i8** %p, i8* %n) { +; CHECK-NEXT: %1 = call i8* @objc_initWeak(i8** %p, i8* %n) +; CHECK-NEXT: call void @use_pointer(i8* %n) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test6(i8** %p, i8* %n) { + call i8* @objc_initWeak(i8** %p, i8* %n) + %y = call i8* @objc_loadWeak(i8** %p) + call void @use_pointer(i8* %y) + ret void +} + +; Don't forward if there's a may-alias store in the way. + +; CHECK: define void @test7(i8** %p, i8* %n, i8** %q, i8* %m) { +; CHECK-NEXT: call i8* @objc_initWeak(i8** %p, i8* %n) +; CHECK-NEXT: call i8* @objc_storeWeak(i8** %q, i8* %m) +; CHECK-NEXT: %y = call i8* @objc_loadWeak(i8** %p) +; CHECK-NEXT: call void @use_pointer(i8* %y) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test7(i8** %p, i8* %n, i8** %q, i8* %m) { + call i8* @objc_initWeak(i8** %p, i8* %n) + call i8* @objc_storeWeak(i8** %q, i8* %m) + %y = call i8* @objc_loadWeak(i8** %p) + call void @use_pointer(i8* %y) + ret void +} diff --git a/test/Transforms/ObjCARC/rv.ll b/test/Transforms/ObjCARC/rv.ll new file mode 100644 index 0000000000..da53a86b10 --- /dev/null +++ b/test/Transforms/ObjCARC/rv.ll @@ -0,0 +1,331 @@ +; RUN: opt -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 i8* @objc_retainAutoreleaseReturnValue(i8*) +declare void @objc_autoreleasePoolPop(i8*) +declare void @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() + +; Test that retain+release elimination is suppressed when the +; retain is an objc_retainAutoreleasedReturnValue, since it's +; better to do the RV optimization. + +; CHECK: define void @test0( +; CHECK-NEXT: entry: +; CHECK-NEXT: %x = call i8* @returner +; CHECK-NEXT: %0 = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %x) nounwind +; CHECK: t: +; CHECK-NOT: @objc_ +; CHECK: return: +; CHECK-NEXT: call void @objc_release(i8* %x) +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @test0(i1 %p) nounwind { +entry: + %x = call i8* @returner() + %0 = call i8* @objc_retainAutoreleasedReturnValue(i8* %x) + br i1 %p, label %t, label %return + +t: + call void @use_pointer(i8* %x) + store i8 0, i8* %x + br label %return + +return: + call void @objc_release(i8* %x) nounwind + ret void +} + +; Delete no-ops. + +; CHECK: define void @test2 +; CHECK-NOT: @objc_ +; CHECK: } +define void @test2() { + call i8* @objc_retainAutoreleasedReturnValue(i8* null) + call i8* @objc_autoreleaseReturnValue(i8* null) + ; call i8* @objc_retainAutoreleaseReturnValue(i8* null) ; TODO + ret void +} + +; Delete a redundant retainRV,autoreleaseRV when forwaring a call result +; directly to a return value. + +; CHECK: define i8* @test3 +; CHECK: call i8* @returner() +; CHECK-NEXT: ret i8* %call +define i8* @test3() { +entry: + %call = call i8* @returner() + %0 = call i8* @objc_retainAutoreleasedReturnValue(i8* %call) nounwind + %1 = call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind + ret i8* %1 +} + +; Delete a redundant retain,autoreleaseRV when forwaring a call result +; directly to a return value. + +; CHECK: define i8* @test4 +; CHECK: call i8* @returner() +; CHECK-NEXT: ret i8* %call +define i8* @test4() { +entry: + %call = call i8* @returner() + %0 = call i8* @objc_retain(i8* %call) nounwind + %1 = call i8* @objc_autoreleaseReturnValue(i8* %0) nounwind + ret i8* %1 +} + +; Delete a redundant fused retain+autoreleaseRV when forwaring a call result +; directly to a return value. + +; TODO +; HECK: define i8* @test5 +; HECK: call i8* @returner() +; HECK-NEXT: ret i8* %call +;define i8* @test5() { +;entry: +; %call = call i8* @returner() +; %0 = call i8* @objc_retainAutoreleaseReturnValue(i8* %call) nounwind +; ret i8* %0 +;} + +; Don't eliminate objc_retainAutoreleasedReturnValue by merging it into +; an objc_autorelease. +; TODO? Merge objc_retainAutoreleasedReturnValue and objc_autorelease into +; objc_retainAutoreleasedReturnValueAutorelease and merge +; objc_retainAutoreleasedReturnValue and objc_autoreleaseReturnValue +; into objc_retainAutoreleasedReturnValueAutoreleaseReturnValue? +; Those entrypoints don't exist yet though. + +; CHECK: define i8* @test7( +; CHECK: call i8* @objc_retainAutoreleasedReturnValue(i8* %p) +; CHECK: %t = tail call i8* @objc_autoreleaseReturnValue(i8* %p) +define i8* @test7() { + %p = call i8* @returner() + call i8* @objc_retainAutoreleasedReturnValue(i8* %p) + %t = call i8* @objc_autoreleaseReturnValue(i8* %p) + call void @use_pointer(i8* %t) + ret i8* %t +} + +; CHECK: define i8* @test7b( +; CHECK: call i8* @objc_retain(i8* %p) +; CHECK: %t = tail call i8* @objc_autoreleaseReturnValue(i8* %p) +define i8* @test7b() { + %p = call i8* @returner() + call void @use_pointer(i8* %p) + call i8* @objc_retainAutoreleasedReturnValue(i8* %p) + %t = call i8* @objc_autoreleaseReturnValue(i8* %p) + ret i8* %t +} + +; Turn objc_retain into objc_retainAutoreleasedReturnValue if its operand +; is a return value. + +; CHECK: define void @test8() +; CHECK: tail call i8* @objc_retainAutoreleasedReturnValue(i8* %p) +define void @test8() { + %p = call i8* @returner() + call i8* @objc_retain(i8* %p) + ret void +} + +; Don't apply the RV optimization to autorelease if there's no retain. + +; CHECK: define i8* @test9(i8* %p) +; CHECK: tail call i8* @objc_autorelease(i8* %p) +define i8* @test9(i8* %p) { + call i8* @objc_autorelease(i8* %p) + ret i8* %p +} + +; Apply the RV optimization. + +; CHECK: define i8* @test10(i8* %p) +; CHECK: tail call i8* @objc_retain(i8* %p) nounwind +; CHECK: tail call i8* @objc_autoreleaseReturnValue(i8* %p) nounwind +; CHECK-NEXT: ret i8* %p +define i8* @test10(i8* %p) { + %1 = call i8* @objc_retain(i8* %p) + %2 = call i8* @objc_autorelease(i8* %p) + ret i8* %p +} + +; Don't do the autoreleaseRV optimization because @use_pointer +; could undo the retain. + +; CHECK: define i8* @test11(i8* %p) +; CHECK: tail call i8* @objc_retain(i8* %p) +; CHECK-NEXT: call void @use_pointer(i8* %p) +; CHECK: tail call i8* @objc_autorelease(i8* %p) +; CHECK-NEXT: ret i8* %p +define i8* @test11(i8* %p) { + %1 = call i8* @objc_retain(i8* %p) + call void @use_pointer(i8* %p) + %2 = call i8* @objc_autorelease(i8* %p) + ret i8* %p +} + +; Don't spoil the RV optimization. + +; CHECK: define i8* @test12(i8* %p) +; CHECK: tail call i8* @objc_retain(i8* %p) +; CHECK: call void @use_pointer(i8* %p) +; CHECK: tail call i8* @objc_autoreleaseReturnValue(i8* %p) +; CHECK: ret i8* %p +define i8* @test12(i8* %p) { + %1 = call i8* @objc_retain(i8* %p) + call void @use_pointer(i8* %p) + %2 = call i8* @objc_autoreleaseReturnValue(i8* %p) + ret i8* %p +} + +; Don't zap the objc_retainAutoreleasedReturnValue. + +; CHECK: define i8* @test13( +; CHECK: tail call i8* @objc_retainAutoreleasedReturnValue(i8* %p) +; CHECK: tail call i8* @objc_autorelease(i8* %p) +; CHECK: ret i8* %p +define i8* @test13() { + %p = call i8* @returner() + %1 = call i8* @objc_retainAutoreleasedReturnValue(i8* %p) + call void @callee() + %2 = call i8* @objc_autorelease(i8* %p) + ret i8* %p +} + +; Convert objc_retainAutoreleasedReturnValue to objc_retain if its +; argument is not a return value. + +; CHECK: define void @test14( +; CHECK-NEXT: tail call i8* @objc_retain(i8* %p) nounwind +; CHECK-NEXT: ret void +define void @test14(i8* %p) { + call i8* @objc_retainAutoreleasedReturnValue(i8* %p) + ret void +} + +; Don't convert objc_retainAutoreleasedReturnValue to objc_retain if its +; argument is a return value. + +; CHECK: define void @test15( +; CHECK-NEXT: %y = call i8* @returner() +; CHECK-NEXT: tail call i8* @objc_retainAutoreleasedReturnValue(i8* %y) nounwind +; CHECK-NEXT: ret void +define void @test15() { + %y = call i8* @returner() + call i8* @objc_retainAutoreleasedReturnValue(i8* %y) + ret void +} + +; Convert objc_retain to objc_retainAutoreleasedReturnValue if its +; argument is a return value. + +; CHECK: define void @test16( +; CHECK-NEXT: %y = call i8* @returner() +; CHECK-NEXT: tail call i8* @objc_retainAutoreleasedReturnValue(i8* %y) nounwind +; CHECK-NEXT: ret void +define void @test16() { + %y = call i8* @returner() + call i8* @objc_retain(i8* %y) + ret void +} + +; Don't convert objc_retain to objc_retainAutoreleasedReturnValue if its +; argument is not a return value. + +; CHECK: define void @test17( +; CHECK-NEXT: tail call i8* @objc_retain(i8* %y) nounwind +; CHECK-NEXT: ret void +define void @test17(i8* %y) { + call i8* @objc_retain(i8* %y) + ret void +} + +; Don't Convert objc_retain to objc_retainAutoreleasedReturnValue if it +; isn't next to the call providing its return value. + +; CHECK: define void @test18( +; CHECK-NEXT: %y = call i8* @returner() +; CHECK-NEXT: call void @callee() +; CHECK-NEXT: tail call i8* @objc_retain(i8* %y) nounwind +; CHECK-NEXT: ret void +define void @test18() { + %y = call i8* @returner() + call void @callee() + call i8* @objc_retain(i8* %y) + ret void +} + +; Delete autoreleaseRV+retainRV pairs. + +; CHECK: define i8* @test19(i8* %p) { +; CHECK-NEXT: ret i8* %p +define i8* @test19(i8* %p) { + call i8* @objc_autoreleaseReturnValue(i8* %p) + call i8* @objc_retainAutoreleasedReturnValue(i8* %p) + ret i8* %p +} + +; Like test19 but with plain autorelease. + +; CHECK: define i8* @test20(i8* %p) { +; CHECK-NEXT: call i8* @objc_autorelease(i8* %p) +; CHECK-NEXT: call i8* @objc_retain(i8* %p) +; CHECK-NEXT: ret i8* %p +define i8* @test20(i8* %p) { + call i8* @objc_autorelease(i8* %p) + call i8* @objc_retainAutoreleasedReturnValue(i8* %p) + ret i8* %p +} + +; Like test19 but with plain retain. + +; CHECK: define i8* @test21(i8* %p) { +; CHECK-NEXT: call i8* @objc_autoreleaseReturnValue(i8* %p) +; CHECK-NEXT: call i8* @objc_retain(i8* %p) +; CHECK-NEXT: ret i8* %p +define i8* @test21(i8* %p) { + call i8* @objc_autoreleaseReturnValue(i8* %p) + call i8* @objc_retain(i8* %p) + ret i8* %p +} + +; Like test19 but with plain retain and autorelease. + +; CHECK: define i8* @test22(i8* %p) { +; CHECK-NEXT: call i8* @objc_autorelease(i8* %p) +; CHECK-NEXT: call i8* @objc_retain(i8* %p) +; CHECK-NEXT: ret i8* %p +define i8* @test22(i8* %p) { + call i8* @objc_autorelease(i8* %p) + call i8* @objc_retain(i8* %p) + ret i8* %p +} + +; Convert autoreleaseRV to autorelease. + +; CHECK: define void @test23( +; CHECK: tail call i8* @objc_autorelease(i8* %p) nounwind +define void @test23(i8* %p) { + store i8 0, i8* %p + call i8* @objc_autoreleaseReturnValue(i8* %p) + ret void +} diff --git a/test/Transforms/ObjCARC/weak-contract.ll b/test/Transforms/ObjCARC/weak-contract.ll new file mode 100644 index 0000000000..ca69c7087d --- /dev/null +++ b/test/Transforms/ObjCARC/weak-contract.ll @@ -0,0 +1,14 @@ +; RUN: opt -objc-arc-contract -S < %s | FileCheck %s + +declare i8* @objc_initWeak(i8**, i8*) + +; Convert objc_initWeak(p, null) to *p = null. + +; CHECK: define i8* @test0(i8** %p) { +; CHECK-NEXT: store i8* null, i8** %p +; CHECK-NEXT: ret i8* null +; CHECK-NEXT: } +define i8* @test0(i8** %p) { + %t = call i8* @objc_initWeak(i8** %p, i8* null) + ret i8* %t +} diff --git a/test/Transforms/ObjCARC/weak-copies.ll b/test/Transforms/ObjCARC/weak-copies.ll new file mode 100644 index 0000000000..e1a94bb474 --- /dev/null +++ b/test/Transforms/ObjCARC/weak-copies.ll @@ -0,0 +1,87 @@ +; RUN: opt -S -basicaa -objc-arc < %s | FileCheck %s + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" +target triple = "x86_64-apple-darwin11.0.0" + +%0 = type { i64, i64, i8*, i8*, i8*, i8* } +%1 = type <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i8* }> +%struct.__block_descriptor = type { i64, i64 } + +@_NSConcreteStackBlock = external global i8* +@.str = private unnamed_addr constant [6 x i8] c"v8@?0\00" +@"\01L_OBJC_CLASS_NAME_" = internal global [3 x i8] c"\01@\00", section "__TEXT,__objc_classname,cstring_literals", align 1 +@__block_descriptor_tmp = internal constant %0 { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_ to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_ to i8*), i8* getelementptr inbounds ([6 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8]* @"\01L_OBJC_CLASS_NAME_", i32 0, i32 0) } +@"\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 [2 x i8*] [i8* getelementptr inbounds ([3 x i8]* @"\01L_OBJC_CLASS_NAME_", i32 0, i32 0), i8* bitcast ([2 x i32]* @"\01L_OBJC_IMAGE_INFO" to i8*)], section "llvm.metadata" + +; Eliminate unnecessary weak pointer copies. + +; CHECK: define void @foo() { +; CHECK-NEXT: entry: +; CHECK-NEXT: %call = call i8* @bar() +; CHECK-NEXT: call void @use(i8* %call) nounwind +; CHECK-NEXT: ret void +; CHECK-NEXT: } +define void @foo() { +entry: + %w = alloca i8*, align 8 + %x = alloca i8*, align 8 + %call = call i8* @bar() + %0 = call i8* @objc_initWeak(i8** %w, i8* %call) nounwind + %1 = call i8* @objc_loadWeak(i8** %w) nounwind + %2 = call i8* @objc_initWeak(i8** %x, i8* %1) nounwind + %3 = call i8* @objc_loadWeak(i8** %x) nounwind + call void @use(i8* %3) nounwind + call void @objc_destroyWeak(i8** %x) nounwind + call void @objc_destroyWeak(i8** %w) nounwind + ret void +} + +; Eliminate unnecessary weak pointer copies in a block initialization. + +; CHECK: define void @qux(i8* %me) nounwind { +; CHECK-NEXT: entry: +; CHECK-NEXT: %block = alloca %1, align 8 +; CHECK-NOT: alloca +; CHECK: } +define void @qux(i8* %me) nounwind { +entry: + %w = alloca i8*, align 8 + %block = alloca %1, align 8 + %0 = call i8* @objc_retain(i8* %me) nounwind + %1 = call i8* @objc_initWeak(i8** %w, i8* %0) nounwind + %block.isa = getelementptr inbounds %1* %block, i64 0, i32 0 + store i8* bitcast (i8** @_NSConcreteStackBlock to i8*), i8** %block.isa, align 8 + %block.flags = getelementptr inbounds %1* %block, i64 0, i32 1 + store i32 1107296256, i32* %block.flags, align 8 + %block.reserved = getelementptr inbounds %1* %block, i64 0, i32 2 + store i32 0, i32* %block.reserved, align 4 + %block.invoke = getelementptr inbounds %1* %block, i64 0, i32 3 + store i8* bitcast (void (i8*)* @__qux_block_invoke_0 to i8*), i8** %block.invoke, align 8 + %block.descriptor = getelementptr inbounds %1* %block, i64 0, i32 4 + store %struct.__block_descriptor* bitcast (%0* @__block_descriptor_tmp to %struct.__block_descriptor*), %struct.__block_descriptor** %block.descriptor, align 8 + %block.captured = getelementptr inbounds %1* %block, i64 0, i32 5 + %2 = call i8* @objc_loadWeak(i8** %w) nounwind + %3 = call i8* @objc_initWeak(i8** %block.captured, i8* %2) nounwind + %4 = bitcast %1* %block to void ()* + call void @use_block(void ()* %4) nounwind + call void @objc_destroyWeak(i8** %block.captured) nounwind + call void @objc_destroyWeak(i8** %w) nounwind + call void @objc_release(i8* %0) nounwind, !clang.imprecise_release !0 + ret void +} + +declare i8* @objc_retain(i8*) +declare void @use_block(void ()*) nounwind +declare void @__qux_block_invoke_0(i8* %.block_descriptor) nounwind +declare void @__copy_helper_block_(i8*, i8*) nounwind +declare void @objc_copyWeak(i8**, i8**) +declare void @__destroy_helper_block_(i8*) nounwind +declare void @objc_release(i8*) +declare i8* @bar() +declare i8* @objc_initWeak(i8**, i8*) +declare i8* @objc_loadWeak(i8**) +declare void @use(i8*) nounwind +declare void @objc_destroyWeak(i8**) + +!0 = metadata !{} diff --git a/test/Transforms/ObjCARC/weak.ll b/test/Transforms/ObjCARC/weak.ll new file mode 100644 index 0000000000..85a290c098 --- /dev/null +++ b/test/Transforms/ObjCARC/weak.ll @@ -0,0 +1,57 @@ +; RUN: opt -objc-arc -S < %s | FileCheck %s + +declare i8* @objc_initWeak(i8**, i8*) +declare i8* @objc_storeWeak(i8**, i8*) +declare i8* @objc_loadWeak(i8**) +declare void @objc_destroyWeak(i8**) +declare i8* @objc_loadWeakRetained(i8**) +declare void @objc_moveWeak(i8**, i8**) +declare void @objc_copyWeak(i8**, i8**) + +; If the pointer-to-weak-pointer is null, it's undefined behavior. + +; CHECK: define void @test0( +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: store i8* undef, i8** null +; CHECK: ret void +define void @test0(i8* %p, i8** %q) { +entry: + call i8* @objc_storeWeak(i8** null, i8* %p) + call i8* @objc_storeWeak(i8** undef, i8* %p) + call i8* @objc_loadWeakRetained(i8** null) + call i8* @objc_loadWeakRetained(i8** undef) + call i8* @objc_loadWeak(i8** null) + call i8* @objc_loadWeak(i8** undef) + call i8* @objc_initWeak(i8** null, i8* %p) + call i8* @objc_initWeak(i8** undef, i8* %p) + call void @objc_destroyWeak(i8** null) + call void @objc_destroyWeak(i8** undef) + + call void @objc_copyWeak(i8** null, i8** %q) + call void @objc_copyWeak(i8** undef, i8** %q) + call void @objc_copyWeak(i8** %q, i8** null) + call void @objc_copyWeak(i8** %q, i8** undef) + + call void @objc_moveWeak(i8** null, i8** %q) + call void @objc_moveWeak(i8** undef, i8** %q) + call void @objc_moveWeak(i8** %q, i8** null) + call void @objc_moveWeak(i8** %q, i8** undef) + + ret void +} |