test/Transforms/ObjCARC/rv.ll

   1 ; RUN: opt -objc-arc -S < %s | FileCheck %s
   2
   3 target datalayout = "e-p:64:64:64"
   4
   5 declare i8* @llvm.objc.retain(i8*)
   6 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
   7 declare void @llvm.objc.release(i8*)
   8 declare i8* @llvm.objc.autorelease(i8*)
   9 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
  10 declare i8* @llvm.objc.retainAutoreleaseReturnValue(i8*)
  11 declare void @llvm.objc.autoreleasePoolPop(i8*)
  12 declare void @llvm.objc.autoreleasePoolPush()
  13 declare i8* @llvm.objc.retainBlock(i8*)
  14
  15 declare i8* @objc_retainedObject(i8*)
  16 declare i8* @objc_unretainedObject(i8*)
  17 declare i8* @objc_unretainedPointer(i8*)
  18
  19 declare void @use_pointer(i8*)
  20 declare void @callee()
  21 declare void @callee_fnptr(void ()*)
  22 declare void @invokee()
  23 declare i8* @returner()
  24
  25 ; Test that retain+release elimination is suppressed when the
  26 ; retain is an objc_retainAutoreleasedReturnValue, since it's
  27 ; better to do the RV optimization.
  28
  29 ; CHECK-LABEL:      define void @test0(
  30 ; CHECK-NEXT: entry:
  31 ; CHECK-NEXT:   %x = call i8* @returner
  32 ; CHECK-NEXT:   %0 = tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %x) [[NUW:#[0-9]+]]
  33 ; CHECK: t:
  34 ; CHECK-NOT: @llvm.objc.
  35 ; CHECK: return:
  36 ; CHECK-NEXT: call void @llvm.objc.release(i8* %x)
  37 ; CHECK-NEXT: ret void
  38 ; CHECK-NEXT: }
  39 define void @test0(i1 %p) nounwind {
  40 entry:
  41   %x = call i8* @returner()
  42   %0 = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %x)
  43   br i1 %p, label %t, label %return
  44
  45 t:
  46   call void @use_pointer(i8* %x)
  47   store i8 0, i8* %x
  48   br label %return
  49
  50 return:
  51   call void @llvm.objc.release(i8* %x) nounwind
  52   ret void
  53 }
  54
  55 ; Delete no-ops.
  56
  57 ; CHECK-LABEL: define void @test2(
  58 ; CHECK-NOT: @llvm.objc.
  59 ; CHECK: }
  60 define void @test2() {
  61   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* null)
  62   call i8* @llvm.objc.autoreleaseReturnValue(i8* null)
  63   ; call i8* @llvm.objc.retainAutoreleaseReturnValue(i8* null) ; TODO
  64   %bitcast = bitcast i32* null to i8*
  65   %rb = call i8* @llvm.objc.retainBlock(i8* %bitcast)
  66   call void @use_pointer(i8* %rb)
  67   %rb2 = call i8* @llvm.objc.retainBlock(i8* undef)
  68   call void @use_pointer(i8* %rb2)
  69   ret void
  70 }
  71
  72 ; Delete a redundant retainRV,autoreleaseRV when forwaring a call result
  73 ; directly to a return value.
  74
  75 ; CHECK-LABEL: define i8* @test3(
  76 ; CHECK: call i8* @returner()
  77 ; CHECK-NEXT: ret i8* %call
  78 define i8* @test3() {
  79 entry:
  80   %call = call i8* @returner()
  81   %0 = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %call) nounwind
  82   %1 = call i8* @llvm.objc.autoreleaseReturnValue(i8* %0) nounwind
  83   ret i8* %1
  84 }
  85
  86 ; Delete a redundant retain,autoreleaseRV when forwaring a call result
  87 ; directly to a return value.
  88
  89 ; CHECK-LABEL: define i8* @test4(
  90 ; CHECK: call i8* @returner()
  91 ; CHECK-NEXT: ret i8* %call
  92 define i8* @test4() {
  93 entry:
  94   %call = call i8* @returner()
  95   %0 = call i8* @llvm.objc.retain(i8* %call) nounwind
  96   %1 = call i8* @llvm.objc.autoreleaseReturnValue(i8* %0) nounwind
  97   ret i8* %1
  98 }
  99
 100 ; Delete a redundant fused retain+autoreleaseRV when forwaring a call result
 101 ; directly to a return value.
 102
 103 ; TODO
 104 ; HECK: define i8* @test5
 105 ; HECK: call i8* @returner()
 106 ; HECK-NEXT: ret i8* %call
 107 ;define i8* @test5() {
 108 ;entry:
 109 ;  %call = call i8* @returner()
 110 ;  %0 = call i8* @llvm.objc.retainAutoreleaseReturnValue(i8* %call) nounwind
 111 ;  ret i8* %0
 112 ;}
 113
 114 ; Don't eliminate objc_retainAutoreleasedReturnValue by merging it into
 115 ; an objc_autorelease.
 116 ; TODO? Merge objc_retainAutoreleasedReturnValue and objc_autorelease into
 117 ; objc_retainAutoreleasedReturnValueAutorelease and merge
 118 ; objc_retainAutoreleasedReturnValue and objc_autoreleaseReturnValue
 119 ; into objc_retainAutoreleasedReturnValueAutoreleaseReturnValue?
 120 ; Those entrypoints don't exist yet though.
 121
 122 ; CHECK-LABEL: define i8* @test7(
 123 ; CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 124 ; CHECK: %t = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 125 define i8* @test7() {
 126   %p = call i8* @returner()
 127   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 128   %t = call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 129   call void @use_pointer(i8* %p)
 130   ret i8* %t
 131 }
 132
 133 ; CHECK-LABEL: define i8* @test7b(
 134 ; CHECK: call i8* @llvm.objc.retain(i8* %p)
 135 ; CHECK: %t = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 136 define i8* @test7b() {
 137   %p = call i8* @returner()
 138   call void @use_pointer(i8* %p)
 139   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 140   %t = call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 141   ret i8* %p
 142 }
 143
 144 ; Don't apply the RV optimization to autorelease if there's no retain.
 145
 146 ; CHECK: define i8* @test9(i8* %p)
 147 ; CHECK: call i8* @llvm.objc.autorelease(i8* %p)
 148 define i8* @test9(i8* %p) {
 149   call i8* @llvm.objc.autorelease(i8* %p)
 150   ret i8* %p
 151 }
 152
 153 ; Do not apply the RV optimization.
 154
 155 ; CHECK: define i8* @test10(i8* %p)
 156 ; CHECK: tail call i8* @llvm.objc.retain(i8* %p) [[NUW]]
 157 ; CHECK: call i8* @llvm.objc.autorelease(i8* %p) [[NUW]]
 158 ; CHECK-NEXT: ret i8* %p
 159 define i8* @test10(i8* %p) {
 160   %1 = call i8* @llvm.objc.retain(i8* %p)
 161   %2 = call i8* @llvm.objc.autorelease(i8* %p)
 162   ret i8* %p
 163 }
 164
 165 ; Don't do the autoreleaseRV optimization because @use_pointer
 166 ; could undo the retain.
 167
 168 ; CHECK: define i8* @test11(i8* %p)
 169 ; CHECK: tail call i8* @llvm.objc.retain(i8* %p)
 170 ; CHECK-NEXT: call void @use_pointer(i8* %p)
 171 ; CHECK: call i8* @llvm.objc.autorelease(i8* %p)
 172 ; CHECK-NEXT: ret i8* %p
 173 define i8* @test11(i8* %p) {
 174   %1 = call i8* @llvm.objc.retain(i8* %p)
 175   call void @use_pointer(i8* %p)
 176   %2 = call i8* @llvm.objc.autorelease(i8* %p)
 177   ret i8* %p
 178 }
 179
 180 ; Don't spoil the RV optimization.
 181
 182 ; CHECK: define i8* @test12(i8* %p)
 183 ; CHECK: tail call i8* @llvm.objc.retain(i8* %p)
 184 ; CHECK: call void @use_pointer(i8* %p)
 185 ; CHECK: tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 186 ; CHECK: ret i8* %p
 187 define i8* @test12(i8* %p) {
 188   %1 = call i8* @llvm.objc.retain(i8* %p)
 189   call void @use_pointer(i8* %p)
 190   %2 = call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 191   ret i8* %p
 192 }
 193
 194 ; Don't zap the objc_retainAutoreleasedReturnValue.
 195
 196 ; CHECK-LABEL: define i8* @test13(
 197 ; CHECK: tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 198 ; CHECK: call i8* @llvm.objc.autorelease(i8* %p)
 199 ; CHECK: ret i8* %p
 200 define i8* @test13() {
 201   %p = call i8* @returner()
 202   %1 = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 203   call void @callee()
 204   %2 = call i8* @llvm.objc.autorelease(i8* %p)
 205   ret i8* %p
 206 }
 207
 208 ; Convert objc_retainAutoreleasedReturnValue to objc_retain if its
 209 ; argument is not a return value.
 210
 211 ; CHECK-LABEL: define void @test14(
 212 ; CHECK-NEXT: tail call i8* @llvm.objc.retain(i8* %p) [[NUW]]
 213 ; CHECK-NEXT: ret void
 214 define void @test14(i8* %p) {
 215   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 216   ret void
 217 }
 218
 219 ; Don't convert objc_retainAutoreleasedReturnValue to objc_retain if its
 220 ; argument is a return value.
 221
 222 ; CHECK-LABEL: define void @test15(
 223 ; CHECK-NEXT: %y = call i8* @returner()
 224 ; CHECK-NEXT: tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %y) [[NUW]]
 225 ; CHECK-NEXT: ret void
 226 define void @test15() {
 227   %y = call i8* @returner()
 228   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %y)
 229   ret void
 230 }
 231
 232 ; Delete autoreleaseRV+retainRV pairs.
 233
 234 ; CHECK: define i8* @test19(i8* %p) {
 235 ; CHECK-NEXT: ret i8* %p
 236 define i8* @test19(i8* %p) {
 237   call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 238   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 239   ret i8* %p
 240 }
 241
 242 ; Delete autoreleaseRV+retainRV pairs when they have equivalent PHIs as inputs
 243
 244 ; CHECK: define i8* @test19phi(i8* %p) {
 245 ; CHECK-NEXT: entry:
 246 ; CHECK-NEXT: br label %test19bb
 247 ; CHECK: test19bb:
 248 ; CHECK-NEXT: ret i8* %p
 249 define i8* @test19phi(i8* %p) {
 250 entry:
 251   br label %test19bb
 252 test19bb:
 253   %phi1 = phi i8* [ %p, %entry ]
 254   %phi2 = phi i8* [ %p, %entry ]
 255   call i8* @llvm.objc.autoreleaseReturnValue(i8* %phi1)
 256   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %phi2)
 257   ret i8* %p
 258 }
 259
 260 ; Like test19 but with plain autorelease.
 261
 262 ; CHECK: define i8* @test20(i8* %p) {
 263 ; CHECK-NEXT: call i8* @llvm.objc.autorelease(i8* %p)
 264 ; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %p)
 265 ; CHECK-NEXT: ret i8* %p
 266 define i8* @test20(i8* %p) {
 267   call i8* @llvm.objc.autorelease(i8* %p)
 268   call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %p)
 269   ret i8* %p
 270 }
 271
 272 ; Like test19 but with plain retain.
 273
 274 ; CHECK: define i8* @test21(i8* %p) {
 275 ; CHECK-NEXT: call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 276 ; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %p)
 277 ; CHECK-NEXT: ret i8* %p
 278 define i8* @test21(i8* %p) {
 279   call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 280   call i8* @llvm.objc.retain(i8* %p)
 281   ret i8* %p
 282 }
 283
 284 ; Like test19 but with plain retain and autorelease.
 285
 286 ; CHECK: define i8* @test22(i8* %p) {
 287 ; CHECK-NEXT: call i8* @llvm.objc.autorelease(i8* %p)
 288 ; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %p)
 289 ; CHECK-NEXT: ret i8* %p
 290 define i8* @test22(i8* %p) {
 291   call i8* @llvm.objc.autorelease(i8* %p)
 292   call i8* @llvm.objc.retain(i8* %p)
 293   ret i8* %p
 294 }
 295
 296 ; Convert autoreleaseRV to autorelease.
 297
 298 ; CHECK-LABEL: define void @test23(
 299 ; CHECK: call i8* @llvm.objc.autorelease(i8* %p) [[NUW]]
 300 define void @test23(i8* %p) {
 301   store i8 0, i8* %p
 302   call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 303   ret void
 304 }
 305
 306 ; Don't convert autoreleaseRV to autorelease if the result is returned,
 307 ; even through a bitcast.
 308
 309 ; CHECK-LABEL: define {}* @test24(
 310 ; CHECK: tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 311 define {}* @test24(i8* %p) {
 312   %t = call i8* @llvm.objc.autoreleaseReturnValue(i8* %p)
 313   %s = bitcast i8* %p to {}*
 314   ret {}* %s
 315 }
 316
 317 declare i8* @first_test25();
 318 declare i8* @second_test25(i8*);
 319 declare void @somecall_test25();
 320
 321 ; ARC optimizer used to move the last release between the call to second_test25
 322 ; and the call to objc_retainAutoreleasedReturnValue, causing %second to be
 323 ; released prematurely when %first and %second were pointing to the same object.
 324
 325 ; CHECK-LABEL: define void @test25(
 326 ; CHECK: %[[CALL1:.*]] = call i8* @second_test25(
 327 ; CHECK-NEXT: tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL1]])
 328
 329 define void @test25() {
 330   %first = call i8* @first_test25()
 331   %v0 = call i8* @llvm.objc.retain(i8* %first)
 332   call void @somecall_test25()
 333   %second = call i8* @second_test25(i8* %first)
 334   %call2 = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %second)
 335   call void @llvm.objc.release(i8* %second), !clang.imprecise_release !0
 336   call void @llvm.objc.release(i8* %first), !clang.imprecise_release !0
 337   ret void
 338 }
 339
 340 ; Check that ObjCARCOpt::OptimizeReturns removes the redundant calls even when
 341 ; they are not in the same basic block. This code used to cause an assertion
 342 ; failure.
 343
 344 ; CHECK-LABEL: define i8* @test26()
 345 ; CHECK: call i8* @returner()
 346 ; CHECK-NOT:  call
 347 define i8* @test26() {
 348 bb0:
 349   %v0 = call i8* @returner()
 350   %v1 = tail call i8* @llvm.objc.retain(i8* %v0)
 351   br label %bb1
 352 bb1:
 353   %v2 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %v1)
 354   br label %bb2
 355 bb2:
 356   ret i8* %v2
 357 }
 358
 359 declare i32* @func27(i32);
 360
 361 ; Check that ObjCARCOpt::OptimizeAutoreleaseRVCall doesn't turn a call to
 362 ; @llvm.objc.autoreleaseReturnValue into a call to @llvm.objc.autorelease when a return
 363 ; instruction uses a value equivalent to @llvm.objc.autoreleaseReturnValue's operand.
 364 ; In the code below, %phival and %retval are considered equivalent.
 365
 366 ; CHECK-LABEL: define i32* @test27(
 367 ; CHECK: %[[PHIVAL:.*]] = phi i8* [ %{{.*}}, %bb1 ], [ %{{.*}}, %bb2 ]
 368 ; CHECK: %[[RETVAL:.*]] = phi i32* [ %{{.*}}, %bb1 ], [ %{{.*}}, %bb2 ]
 369 ; CHECK: tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %[[PHIVAL]])
 370 ; CHECK: ret i32* %[[RETVAL]]
 371
 372 define i32* @test27(i1 %cond) {
 373 entry:
 374   br i1 %cond, label %bb1, label %bb2
 375 bb1:
 376   %v0 = call i32* @func27(i32 1)
 377   %v1 = bitcast i32* %v0 to i8*
 378   br label %bb3
 379 bb2:
 380   %v2 = call i32* @func27(i32 2)
 381   %v3 = bitcast i32* %v2 to i8*
 382   br label %bb3
 383 bb3:
 384   %phival = phi i8* [ %v1, %bb1 ], [ %v3, %bb2 ]
 385   %retval = phi i32* [ %v0, %bb1 ], [ %v2, %bb2 ]
 386   %v4 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %phival)
 387   ret i32* %retval
 388 }
 389
 390 !0 = !{}
 391
 392 ; CHECK: attributes [[NUW]] = { nounwind }