1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
|
; 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 }
|