; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s target datalayout = "e-p:64:64:64" declare ptr @llvm.objc.retain(ptr) declare void @llvm.objc.release(ptr) declare void @use_pointer(ptr) @x = external global ptr ; CHECK-LABEL: define void @test0( ; CHECK: entry: ; CHECK-NEXT: tail call void @llvm.objc.storeStrong(ptr @x, ptr %p) [[NUW:#[0-9]+]] ; CHECK-NEXT: ret void ; CHECK-NEXT: } define void @test0(ptr %p) { entry: %0 = tail call ptr @llvm.objc.retain(ptr %p) nounwind %tmp = load ptr, ptr @x, align 8 store ptr %0, ptr @x, align 8 tail call void @llvm.objc.release(ptr %tmp) nounwind ret void } ; Don't do this if the load is volatile. ; CHECK-LABEL: define void @test1(ptr %p) { ; CHECK-NEXT: entry: ; CHECK-NEXT: %0 = tail call ptr @llvm.objc.retain(ptr %p) [[NUW]] ; CHECK-NEXT: %tmp = load volatile ptr, ptr @x, align 8 ; CHECK-NEXT: store ptr %0, ptr @x, align 8 ; CHECK-NEXT: tail call void @llvm.objc.release(ptr %tmp) [[NUW]] ; CHECK-NEXT: ret void ; CHECK-NEXT: } define void @test1(ptr %p) { entry: %0 = tail call ptr @llvm.objc.retain(ptr %p) nounwind %tmp = load volatile ptr, ptr @x, align 8 store ptr %0, ptr @x, align 8 tail call void @llvm.objc.release(ptr %tmp) nounwind ret void } ; Don't do this if the store is volatile. ; CHECK-LABEL: define void @test2(ptr %p) { ; CHECK-NEXT: entry: ; CHECK-NEXT: %0 = tail call ptr @llvm.objc.retain(ptr %p) [[NUW]] ; CHECK-NEXT: %tmp = load ptr, ptr @x, align 8 ; CHECK-NEXT: store volatile ptr %0, ptr @x, align 8 ; CHECK-NEXT: tail call void @llvm.objc.release(ptr %tmp) [[NUW]] ; CHECK-NEXT: ret void ; CHECK-NEXT: } define void @test2(ptr %p) { entry: %0 = tail call ptr @llvm.objc.retain(ptr %p) nounwind %tmp = load ptr, ptr @x, align 8 store volatile ptr %0, ptr @x, align 8 tail call void @llvm.objc.release(ptr %tmp) nounwind ret void } ; Don't do this if there's a use of the old pointer value between the store ; and the release. ; CHECK-LABEL: define void @test3(ptr %newValue) { ; CHECK-NEXT: entry: ; CHECK-NEXT: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) [[NUW]] ; CHECK-NEXT: %x1 = load ptr, ptr @x, align 8 ; CHECK-NEXT: store ptr %x0, ptr @x, align 8 ; CHECK-NEXT: tail call void @use_pointer(ptr %x1), !clang.arc.no_objc_arc_exceptions !0 ; CHECK-NEXT: tail call void @llvm.objc.release(ptr %x1) [[NUW]], !clang.imprecise_release !0 ; CHECK-NEXT: ret void ; CHECK-NEXT: } define void @test3(ptr %newValue) { entry: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) nounwind %x1 = load ptr, ptr @x, align 8 store ptr %newValue, ptr @x, align 8 tail call void @use_pointer(ptr %x1), !clang.arc.no_objc_arc_exceptions !0 tail call void @llvm.objc.release(ptr %x1) nounwind, !clang.imprecise_release !0 ret void } ; Like test3, but with an icmp use instead of a call, for good measure. ; CHECK-LABEL: define i1 @test4(ptr %newValue, ptr %foo) { ; CHECK-NEXT: entry: ; CHECK-NEXT: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) [[NUW]] ; CHECK-NEXT: %x1 = load ptr, ptr @x, align 8 ; CHECK-NEXT: store ptr %x0, ptr @x, align 8 ; CHECK-NEXT: %t = icmp eq ptr %x1, %foo ; CHECK-NEXT: tail call void @llvm.objc.release(ptr %x1) [[NUW]], !clang.imprecise_release !0 ; CHECK-NEXT: ret i1 %t ; CHECK-NEXT: } define i1 @test4(ptr %newValue, ptr %foo) { entry: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) nounwind %x1 = load ptr, ptr @x, align 8 store ptr %newValue, ptr @x, align 8 %t = icmp eq ptr %x1, %foo tail call void @llvm.objc.release(ptr %x1) nounwind, !clang.imprecise_release !0 ret i1 %t } ; Do form an llvm.objc.storeStrong here, because the use is before the store. ; CHECK-LABEL: define i1 @test5(ptr %newValue, ptr %foo) { ; CHECK: %t = icmp eq ptr %x1, %foo ; CHECK: tail call void @llvm.objc.storeStrong(ptr @x, ptr %newValue) [[NUW]] ; CHECK: } define i1 @test5(ptr %newValue, ptr %foo) { entry: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) nounwind %x1 = load ptr, ptr @x, align 8 %t = icmp eq ptr %x1, %foo store ptr %newValue, ptr @x, align 8 tail call void @llvm.objc.release(ptr %x1) nounwind, !clang.imprecise_release !0 ret i1 %t } ; Like test5, but the release is before the store. ; CHECK-LABEL: define i1 @test6(ptr %newValue, ptr %foo) { ; CHECK: %t = icmp eq ptr %x1, %foo ; CHECK: tail call void @llvm.objc.storeStrong(ptr @x, ptr %newValue) [[NUW]] ; CHECK: } define i1 @test6(ptr %newValue, ptr %foo) { entry: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) nounwind %x1 = load ptr, ptr @x, align 8 tail call void @llvm.objc.release(ptr %x1) nounwind, !clang.imprecise_release !0 %t = icmp eq ptr %x1, %foo store ptr %newValue, ptr @x, align 8 ret i1 %t } ; Like test0, but there's no store, so don't form an llvm.objc.storeStrong. ; CHECK-LABEL: define void @test7( ; CHECK-NEXT: entry: ; CHECK-NEXT: %0 = tail call ptr @llvm.objc.retain(ptr %p) [[NUW]] ; CHECK-NEXT: %tmp = load ptr, ptr @x, align 8 ; CHECK-NEXT: tail call void @llvm.objc.release(ptr %tmp) [[NUW]] ; CHECK-NEXT: ret void ; CHECK-NEXT: } define void @test7(ptr %p) { entry: %0 = tail call ptr @llvm.objc.retain(ptr %p) nounwind %tmp = load ptr, ptr @x, align 8 tail call void @llvm.objc.release(ptr %tmp) nounwind ret void } ; Like test0, but there's no retain, so don't form an llvm.objc.storeStrong. ; CHECK-LABEL: define void @test8( ; CHECK-NEXT: entry: ; CHECK-NEXT: %tmp = load ptr, ptr @x, align 8 ; CHECK-NEXT: store ptr %p, ptr @x, align 8 ; CHECK-NEXT: tail call void @llvm.objc.release(ptr %tmp) [[NUW]] ; CHECK-NEXT: ret void ; CHECK-NEXT: } define void @test8(ptr %p) { entry: %tmp = load ptr, ptr @x, align 8 store ptr %p, ptr @x, align 8 tail call void @llvm.objc.release(ptr %tmp) nounwind ret void } ; Make sure that we properly handle release that *may* release our new ; value in between the retain and the store. We need to be sure that ; this we can safely move the retain to the store. This specific test ; makes sure that we properly handled a release of an unrelated ; pointer. ; ; CHECK-LABEL: define i1 @test9(ptr %newValue, ptr %foo, ptr %unrelated_ptr) { ; CHECK-NOT: llvm.objc.storeStrong define i1 @test9(ptr %newValue, ptr %foo, ptr %unrelated_ptr) { entry: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) nounwind tail call void @llvm.objc.release(ptr %unrelated_ptr) nounwind, !clang.imprecise_release !0 %x1 = load ptr, ptr @x, align 8 tail call void @llvm.objc.release(ptr %x1) nounwind, !clang.imprecise_release !0 %t = icmp eq ptr %x1, %foo store ptr %newValue, ptr @x, align 8 ret i1 %t } ; Make sure that we don't perform the optimization when we just have a call. ; ; CHECK-LABEL: define i1 @test10(ptr %newValue, ptr %foo, ptr %unrelated_ptr) { ; CHECK-NOT: llvm.objc.storeStrong define i1 @test10(ptr %newValue, ptr %foo, ptr %unrelated_ptr) { entry: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) nounwind call void @use_pointer(ptr %unrelated_ptr) %x1 = load ptr, ptr @x, align 8 tail call void @llvm.objc.release(ptr %x1) nounwind, !clang.imprecise_release !0 %t = icmp eq ptr %x1, %foo store ptr %newValue, ptr @x, align 8 ret i1 %t } ; Make sure we form the store strong if the use in between the retain ; and the store does not touch reference counts. ; CHECK-LABEL: define i1 @test11(ptr %newValue, ptr %foo, ptr %unrelated_ptr) { ; CHECK: llvm.objc.storeStrong define i1 @test11(ptr %newValue, ptr %foo, ptr %unrelated_ptr) { entry: %x0 = tail call ptr @llvm.objc.retain(ptr %newValue) nounwind %t = icmp eq ptr %newValue, %foo %x1 = load ptr, ptr @x, align 8 tail call void @llvm.objc.release(ptr %x1) nounwind, !clang.imprecise_release !0 store ptr %newValue, ptr @x, align 8 ret i1 %t } ; Make sure that we form the store strong even if there are bitcasts on ; the pointers. ; CHECK-LABEL: define void @test12( ; CHECK: entry: ; CHECK-NEXT: %p16 = bitcast ptr @x to ptr ; CHECK-NEXT: %tmp16 = load ptr, ptr %p16, align 8 ; CHECK-NEXT: %tmp8 = bitcast ptr %tmp16 to ptr ; CHECK-NEXT: %p32 = bitcast ptr @x to ptr ; CHECK-NEXT: %v32 = bitcast ptr %p to ptr ; CHECK-NEXT: tail call void @llvm.objc.storeStrong(ptr %p16, ptr %p) ; CHECK-NEXT: ret void ; CHECK-NEXT: } define void @test12(ptr %p) { entry: %retain = tail call ptr @llvm.objc.retain(ptr %p) nounwind %p16 = bitcast ptr @x to ptr %tmp16 = load ptr, ptr %p16, align 8 %tmp8 = bitcast ptr %tmp16 to ptr %p32 = bitcast ptr @x to ptr %v32 = bitcast ptr %retain to ptr store ptr %v32, ptr %p32, align 8 tail call void @llvm.objc.release(ptr %tmp8) nounwind ret void } ; This used to crash. ; CHECK-LABEL: define ptr @test13( ; CHECK: tail call void @llvm.objc.storeStrong(ptr %{{.*}}, ptr %[[NEW:.*]]) ; CHECK-NEXT: ret ptr %[[NEW]] define ptr @test13(ptr %a0, ptr %a1, ptr %addr, ptr %new) { %old = load ptr, ptr %addr, align 8 call void @llvm.objc.release(ptr %old) %retained = call ptr @llvm.objc.retain(ptr %new) store ptr %retained, ptr %addr, align 8 ret ptr %retained } ; Cannot form a storeStrong call because it's unsafe to move the release call to ; the store. ; CHECK-LABEL: define void @test14( ; CHECK: %[[V0:.*]] = load ptr, ptr %a ; CHECK: %[[V1:.*]] = call ptr @llvm.objc.retain(ptr %p) ; CHECK: store ptr %[[V1]], ptr %a ; CHECK: %[[V2:.*]] = call ptr @llvm.objc.retain(ptr %[[V0]]) ; CHECK: call void @llvm.objc.release(ptr %[[V2]]) define void @test14(ptr %a, ptr %p) { %v0 = load ptr, ptr %a, align 8 %v1 = call ptr @llvm.objc.retain(ptr %p) store ptr %p, ptr %a, align 8 %v2 = call ptr @llvm.objc.retain(ptr %v0) call void @llvm.objc.release(ptr %v0) ret void } !0 = !{} ; CHECK: attributes [[NUW]] = { nounwind }