test/Transforms/ObjCARC/contract-storestrong.ll

; 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 }