test/Transforms/ObjCARC/allocas.ll

   1 ; RUN: opt -objc-arc -S < %s | FileCheck %s
   2
   3 declare i8* @llvm.objc.retain(i8*)
   4 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
   5 declare void @llvm.objc.release(i8*)
   6 declare i8* @llvm.objc.autorelease(i8*)
   7 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
   8 declare void @llvm.objc.autoreleasePoolPop(i8*)
   9 declare i8* @llvm.objc.autoreleasePoolPush()
  10 declare i8* @llvm.objc.retainBlock(i8*)
  11
  12 declare i8* @objc_retainedObject(i8*)
  13 declare i8* @objc_unretainedObject(i8*)
  14 declare i8* @objc_unretainedPointer(i8*)
  15
  16 declare void @use_pointer(i8*)
  17 declare void @callee()
  18 declare void @callee_fnptr(void ()*)
  19 declare void @invokee()
  20 declare i8* @returner()
  21 declare i8* @returner1()
  22 declare i8* @returner2()
  23 declare void @bar(i32 ()*)
  24 declare void @use_alloca(i8**)
  25
  26 declare void @llvm.dbg.value(metadata, metadata, metadata)
  27
  28 declare i8* @llvm.objc.msgSend(i8*, i8*, ...)
  29
  30
  31 ; In the presence of allocas, unconditionally remove retain/release pairs only
  32 ; if they are known safe in both directions. This prevents matching up an inner
  33 ; retain with the boundary guarding release in the following situation:
  34 ;
  35 ; %A = alloca
  36 ; retain(%x)
  37 ; retain(%x) <--- Inner Retain
  38 ; store %x, %A
  39 ; %y = load %A
  40 ; ... DO STUFF ...
  41 ; release(%y)
  42 ; release(%x) <--- Guarding Release
  43 ;
  44 ; rdar://13750319
  45
  46 ; CHECK: define void @test1a(i8* %x)
  47 ; CHECK: @llvm.objc.retain(i8* %x)
  48 ; CHECK: @llvm.objc.retain(i8* %x)
  49 ; CHECK: @llvm.objc.release(i8* %y)
  50 ; CHECK: @llvm.objc.release(i8* %x)
  51 ; CHECK: ret void
  52 ; CHECK: }
  53 define void @test1a(i8* %x) {
  54 entry:
  55   %A = alloca i8*
  56   tail call i8* @llvm.objc.retain(i8* %x)
  57   tail call i8* @llvm.objc.retain(i8* %x)
  58   store i8* %x, i8** %A, align 8
  59   %y = load i8*, i8** %A
  60   call void @use_alloca(i8** %A)
  61   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
  62   call void @use_pointer(i8* %x)
  63   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
  64   ret void
  65 }
  66
  67 ; CHECK: define void @test1b(i8* %x)
  68 ; CHECK: @llvm.objc.retain(i8* %x)
  69 ; CHECK: @llvm.objc.retain(i8* %x)
  70 ; CHECK: @llvm.objc.release(i8* %y)
  71 ; CHECK: @llvm.objc.release(i8* %x)
  72 ; CHECK: ret void
  73 ; CHECK: }
  74 define void @test1b(i8* %x) {
  75 entry:
  76   %A = alloca i8*
  77   %gep = getelementptr i8*, i8** %A, i32 0
  78   tail call i8* @llvm.objc.retain(i8* %x)
  79   tail call i8* @llvm.objc.retain(i8* %x)
  80   store i8* %x, i8** %gep, align 8
  81   %y = load i8*, i8** %A
  82   call void @use_alloca(i8** %A)
  83   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
  84   call void @use_pointer(i8* %x)
  85   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
  86   ret void
  87 }
  88
  89
  90 ; CHECK: define void @test1c(i8* %x)
  91 ; CHECK: @llvm.objc.retain(i8* %x)
  92 ; CHECK: @llvm.objc.retain(i8* %x)
  93 ; CHECK: @llvm.objc.release(i8* %y)
  94 ; CHECK: @llvm.objc.release(i8* %x)
  95 ; CHECK: ret void
  96 ; CHECK: }
  97 define void @test1c(i8* %x) {
  98 entry:
  99   %A = alloca i8*, i32 3
 100   %gep = getelementptr i8*, i8** %A, i32 2
 101   tail call i8* @llvm.objc.retain(i8* %x)
 102   tail call i8* @llvm.objc.retain(i8* %x)
 103   store i8* %x, i8** %gep, align 8
 104   %y = load i8*, i8** %gep
 105   call void @use_alloca(i8** %A)
 106   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 107   call void @use_pointer(i8* %x)
 108   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 109   ret void
 110 }
 111
 112
 113 ; CHECK: define void @test1d(i8* %x)
 114 ; CHECK: @llvm.objc.retain(i8* %x)
 115 ; CHECK: @llvm.objc.retain(i8* %x)
 116 ; CHECK: @llvm.objc.release(i8* %y)
 117 ; CHECK: @llvm.objc.release(i8* %x)
 118 ; CHECK: ret void
 119 ; CHECK: }
 120 define void @test1d(i8* %x) {
 121 entry:
 122   br i1 undef, label %use_allocaA, label %use_allocaB
 123
 124 use_allocaA:
 125   %allocaA = alloca i8*
 126   br label %exit
 127
 128 use_allocaB:
 129   %allocaB = alloca i8*
 130   br label %exit
 131
 132 exit:
 133   %A = phi i8** [ %allocaA, %use_allocaA ], [ %allocaB, %use_allocaB ]
 134   %gep = getelementptr i8*, i8** %A, i32 0
 135   tail call i8* @llvm.objc.retain(i8* %x)
 136   tail call i8* @llvm.objc.retain(i8* %x)
 137   store i8* %x, i8** %gep, align 8
 138   %y = load i8*, i8** %gep
 139   call void @use_alloca(i8** %A)
 140   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 141   call void @use_pointer(i8* %x)
 142   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 143   ret void
 144 }
 145
 146 ; CHECK: define void @test1e(i8* %x)
 147 ; CHECK: @llvm.objc.retain(i8* %x)
 148 ; CHECK: @llvm.objc.retain(i8* %x)
 149 ; CHECK: @llvm.objc.release(i8* %y)
 150 ; CHECK: @llvm.objc.release(i8* %x)
 151 ; CHECK: ret void
 152 ; CHECK: }
 153 define void @test1e(i8* %x) {
 154 entry:
 155   br i1 undef, label %use_allocaA, label %use_allocaB
 156
 157 use_allocaA:
 158   %allocaA = alloca i8*, i32 4
 159   br label %exit
 160
 161 use_allocaB:
 162   %allocaB = alloca i8*, i32 4
 163   br label %exit
 164
 165 exit:
 166   %A = phi i8** [ %allocaA, %use_allocaA ], [ %allocaB, %use_allocaB ]
 167   %gep = getelementptr i8*, i8** %A, i32 2
 168   tail call i8* @llvm.objc.retain(i8* %x)
 169   tail call i8* @llvm.objc.retain(i8* %x)
 170   store i8* %x, i8** %gep, align 8
 171   %y = load i8*, i8** %gep
 172   call void @use_alloca(i8** %A)
 173   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 174   call void @use_pointer(i8* %x)
 175   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 176   ret void
 177 }
 178
 179 ; CHECK: define void @test1f(i8* %x)
 180 ; CHECK: @llvm.objc.retain(i8* %x)
 181 ; CHECK: @llvm.objc.retain(i8* %x)
 182 ; CHECK: @llvm.objc.release(i8* %y)
 183 ; CHECK: @llvm.objc.release(i8* %x)
 184 ; CHECK: ret void
 185 ; CHECK: }
 186 define void @test1f(i8* %x) {
 187 entry:
 188   %allocaOne = alloca i8*
 189   %allocaTwo = alloca i8*
 190   %A = select i1 undef, i8** %allocaOne, i8** %allocaTwo
 191   tail call i8* @llvm.objc.retain(i8* %x)
 192   tail call i8* @llvm.objc.retain(i8* %x)
 193   store i8* %x, i8** %A, align 8
 194   %y = load i8*, i8** %A
 195   call void @use_alloca(i8** %A)
 196   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 197   call void @use_pointer(i8* %x)
 198   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 199   ret void
 200 }
 201
 202 ; Make sure that if a store is in a different basic block we handle known safe
 203 ; conservatively.
 204
 205
 206 ; CHECK: define void @test2a(i8* %x)
 207 ; CHECK: @llvm.objc.retain(i8* %x)
 208 ; CHECK: @llvm.objc.retain(i8* %x)
 209 ; CHECK: @llvm.objc.release(i8* %y)
 210 ; CHECK: @llvm.objc.release(i8* %x)
 211 ; CHECK: ret void
 212 ; CHECK: }
 213 define void @test2a(i8* %x) {
 214 entry:
 215   %A = alloca i8*
 216   store i8* %x, i8** %A, align 8
 217   %y = load i8*, i8** %A
 218   br label %bb1
 219
 220 bb1:
 221   br label %bb2
 222
 223 bb2:
 224   br label %bb3
 225
 226 bb3:
 227   tail call i8* @llvm.objc.retain(i8* %x)
 228   tail call i8* @llvm.objc.retain(i8* %x)
 229   call void @use_alloca(i8** %A)
 230   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 231   call void @use_pointer(i8* %x)
 232   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 233   ret void
 234 }
 235
 236 ; CHECK: define void @test2b(i8* %x)
 237 ; CHECK: @llvm.objc.retain(i8* %x)
 238 ; CHECK: @llvm.objc.retain(i8* %x)
 239 ; CHECK: @llvm.objc.release(i8* %y)
 240 ; CHECK: @llvm.objc.release(i8* %x)
 241 ; CHECK: ret void
 242 ; CHECK: }
 243 define void @test2b(i8* %x) {
 244 entry:
 245   %A = alloca i8*
 246   %gep1 = getelementptr i8*, i8** %A, i32 0
 247   store i8* %x, i8** %gep1, align 8
 248   %gep2 = getelementptr i8*, i8** %A, i32 0
 249   %y = load i8*, i8** %gep2
 250   br label %bb1
 251
 252 bb1:
 253   br label %bb2
 254
 255 bb2:
 256   br label %bb3
 257
 258 bb3:
 259   tail call i8* @llvm.objc.retain(i8* %x)
 260   tail call i8* @llvm.objc.retain(i8* %x)
 261   call void @use_alloca(i8** %A)
 262   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 263   call void @use_pointer(i8* %x)
 264   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 265   ret void
 266 }
 267
 268 ; CHECK: define void @test2c(i8* %x)
 269 ; CHECK: @llvm.objc.retain(i8* %x)
 270 ; CHECK: @llvm.objc.retain(i8* %x)
 271 ; CHECK: @llvm.objc.release(i8* %y)
 272 ; CHECK: @llvm.objc.release(i8* %x)
 273 ; CHECK: ret void
 274 ; CHECK: }
 275 define void @test2c(i8* %x) {
 276 entry:
 277   %A = alloca i8*, i32 3
 278   %gep1 = getelementptr i8*, i8** %A, i32 2
 279   store i8* %x, i8** %gep1, align 8
 280   %gep2 = getelementptr i8*, i8** %A, i32 2
 281   %y = load i8*, i8** %gep2
 282   tail call i8* @llvm.objc.retain(i8* %x)
 283   br label %bb1
 284
 285 bb1:
 286   br label %bb2
 287
 288 bb2:
 289   br label %bb3
 290
 291 bb3:
 292   tail call i8* @llvm.objc.retain(i8* %x)
 293   call void @use_alloca(i8** %A)
 294   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 295   call void @use_pointer(i8* %x)
 296   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 297   ret void
 298 }
 299
 300 ; CHECK: define void @test2d(i8* %x)
 301 ; CHECK: @llvm.objc.retain(i8* %x)
 302 ; CHECK: @llvm.objc.retain(i8* %x)
 303 ; CHECK: @llvm.objc.release(i8* %y)
 304 ; CHECK: @llvm.objc.release(i8* %x)
 305 ; CHECK: ret void
 306 ; CHECK: }
 307 define void @test2d(i8* %x) {
 308 entry:
 309   tail call i8* @llvm.objc.retain(i8* %x)
 310   br label %bb1
 311
 312 bb1:
 313   %Abb1 = alloca i8*, i32 3
 314   %gepbb11 = getelementptr i8*, i8** %Abb1, i32 2
 315   store i8* %x, i8** %gepbb11, align 8
 316   %gepbb12 = getelementptr i8*, i8** %Abb1, i32 2
 317   %ybb1 = load i8*, i8** %gepbb12
 318   br label %bb3
 319
 320 bb2:
 321   %Abb2 = alloca i8*, i32 4
 322   %gepbb21 = getelementptr i8*, i8** %Abb2, i32 2
 323   store i8* %x, i8** %gepbb21, align 8
 324   %gepbb22 = getelementptr i8*, i8** %Abb2, i32 2
 325   %ybb2 = load i8*, i8** %gepbb22
 326   br label %bb3
 327
 328 bb3:
 329   %A = phi i8** [ %Abb1, %bb1 ], [ %Abb2, %bb2 ]
 330   %y = phi i8* [ %ybb1, %bb1 ], [ %ybb2, %bb2 ]
 331   tail call i8* @llvm.objc.retain(i8* %x)
 332   call void @use_alloca(i8** %A)
 333   call void @llvm.objc.release(i8* %y), !clang.imprecise_release !0
 334   call void @use_pointer(i8* %x)
 335   call void @llvm.objc.release(i8* %x), !clang.imprecise_release !0
 336   ret void
 337 }
 338
 339 ; Make sure in the presence of allocas, if we find a cfghazard we do not perform
 340 ; code motion even if we are known safe. These two concepts are separate and
 341 ; should be treated as such.
 342 ;
 343 ; rdar://13949644
 344
 345 ; CHECK: define void @test3a() {
 346 ; CHECK: entry:
 347 ; CHECK:   @llvm.objc.retainAutoreleasedReturnValue
 348 ; CHECK:   @llvm.objc.retain
 349 ; CHECK:   @llvm.objc.retain
 350 ; CHECK:   @llvm.objc.retain
 351 ; CHECK:   @llvm.objc.retain
 352 ; CHECK: arraydestroy.body:
 353 ; CHECK:   @llvm.objc.release
 354 ; CHECK-NOT: @llvm.objc.release
 355 ; CHECK: arraydestroy.done:
 356 ; CHECK-NOT: @llvm.objc.release
 357 ; CHECK: arraydestroy.body1:
 358 ; CHECK:   @llvm.objc.release
 359 ; CHECK-NOT: @llvm.objc.release
 360 ; CHECK: arraydestroy.done1:
 361 ; CHECK: @llvm.objc.release
 362 ; CHECK: ret void
 363 ; CHECK: }
 364 define void @test3a() {
 365 entry:
 366   %keys = alloca [2 x i8*], align 16
 367   %objs = alloca [2 x i8*], align 16
 368
 369   %call1 = call i8* @returner()
 370   %tmp0 = tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %call1)
 371
 372   %objs.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
 373   tail call i8* @llvm.objc.retain(i8* %call1)
 374   store i8* %call1, i8** %objs.begin, align 8
 375   %objs.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 1
 376   tail call i8* @llvm.objc.retain(i8* %call1)
 377   store i8* %call1, i8** %objs.elt
 378
 379   %call2 = call i8* @returner1()
 380   %call3 = call i8* @returner2()
 381   %keys.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
 382   tail call i8* @llvm.objc.retain(i8* %call2)
 383   store i8* %call2, i8** %keys.begin, align 8
 384   %keys.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 1
 385   tail call i8* @llvm.objc.retain(i8* %call3)
 386   store i8* %call3, i8** %keys.elt
 387
 388   %gep = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 2
 389   br label %arraydestroy.body
 390
 391 arraydestroy.body:
 392   %arraydestroy.elementPast = phi i8** [ %gep, %entry ], [ %arraydestroy.element, %arraydestroy.body ]
 393   %arraydestroy.element = getelementptr inbounds i8*, i8** %arraydestroy.elementPast, i64 -1
 394   %destroy_tmp = load i8*, i8** %arraydestroy.element, align 8
 395   call void @llvm.objc.release(i8* %destroy_tmp), !clang.imprecise_release !0
 396   %objs_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
 397   %arraydestroy.cmp = icmp eq i8** %arraydestroy.element, %objs_ptr
 398   br i1 %arraydestroy.cmp, label %arraydestroy.done, label %arraydestroy.body
 399
 400 arraydestroy.done:
 401   %gep1 = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 2
 402   br label %arraydestroy.body1
 403
 404 arraydestroy.body1:
 405   %arraydestroy.elementPast1 = phi i8** [ %gep1, %arraydestroy.done ], [ %arraydestroy.element1, %arraydestroy.body1 ]
 406   %arraydestroy.element1 = getelementptr inbounds i8*, i8** %arraydestroy.elementPast1, i64 -1
 407   %destroy_tmp1 = load i8*, i8** %arraydestroy.element1, align 8
 408   call void @llvm.objc.release(i8* %destroy_tmp1), !clang.imprecise_release !0
 409   %keys_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
 410   %arraydestroy.cmp1 = icmp eq i8** %arraydestroy.element1, %keys_ptr
 411   br i1 %arraydestroy.cmp1, label %arraydestroy.done1, label %arraydestroy.body1
 412
 413 arraydestroy.done1:
 414   call void @llvm.objc.release(i8* %call1), !clang.imprecise_release !0
 415   ret void
 416 }
 417
 418 ; Make sure that even though we stop said code motion we still allow for
 419 ; pointers to be removed if we are known safe in both directions.
 420 ;
 421 ; rdar://13949644
 422
 423 ; CHECK: define void @test3b() {
 424 ; CHECK: entry:
 425 ; CHECK:   @llvm.objc.retainAutoreleasedReturnValue
 426 ; CHECK:   @llvm.objc.retain
 427 ; CHECK:   @llvm.objc.retain
 428 ; CHECK:   @llvm.objc.retain
 429 ; CHECK:   @llvm.objc.retain
 430 ; CHECK: arraydestroy.body:
 431 ; CHECK:   @llvm.objc.release
 432 ; CHECK-NOT: @llvm.objc.release
 433 ; CHECK: arraydestroy.done:
 434 ; CHECK-NOT: @llvm.objc.release
 435 ; CHECK: arraydestroy.body1:
 436 ; CHECK:   @llvm.objc.release
 437 ; CHECK-NOT: @llvm.objc.release
 438 ; CHECK: arraydestroy.done1:
 439 ; CHECK: @llvm.objc.release
 440 ; CHECK: ret void
 441 ; CHECK: }
 442 define void @test3b() {
 443 entry:
 444   %keys = alloca [2 x i8*], align 16
 445   %objs = alloca [2 x i8*], align 16
 446
 447   %call1 = call i8* @returner()
 448   %tmp0 = tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %call1)
 449   %tmp1 = tail call i8* @llvm.objc.retain(i8* %call1)
 450
 451   %objs.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
 452   tail call i8* @llvm.objc.retain(i8* %call1)
 453   store i8* %call1, i8** %objs.begin, align 8
 454   %objs.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 1
 455   tail call i8* @llvm.objc.retain(i8* %call1)
 456   store i8* %call1, i8** %objs.elt
 457
 458   %call2 = call i8* @returner1()
 459   %call3 = call i8* @returner2()
 460   %keys.begin = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
 461   tail call i8* @llvm.objc.retain(i8* %call2)
 462   store i8* %call2, i8** %keys.begin, align 8
 463   %keys.elt = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 1
 464   tail call i8* @llvm.objc.retain(i8* %call3)
 465   store i8* %call3, i8** %keys.elt
 466
 467   %gep = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 2
 468   br label %arraydestroy.body
 469
 470 arraydestroy.body:
 471   %arraydestroy.elementPast = phi i8** [ %gep, %entry ], [ %arraydestroy.element, %arraydestroy.body ]
 472   %arraydestroy.element = getelementptr inbounds i8*, i8** %arraydestroy.elementPast, i64 -1
 473   %destroy_tmp = load i8*, i8** %arraydestroy.element, align 8
 474   call void @llvm.objc.release(i8* %destroy_tmp), !clang.imprecise_release !0
 475   %objs_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %objs, i64 0, i64 0
 476   %arraydestroy.cmp = icmp eq i8** %arraydestroy.element, %objs_ptr
 477   br i1 %arraydestroy.cmp, label %arraydestroy.done, label %arraydestroy.body
 478
 479 arraydestroy.done:
 480   %gep1 = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 2
 481   br label %arraydestroy.body1
 482
 483 arraydestroy.body1:
 484   %arraydestroy.elementPast1 = phi i8** [ %gep1, %arraydestroy.done ], [ %arraydestroy.element1, %arraydestroy.body1 ]
 485   %arraydestroy.element1 = getelementptr inbounds i8*, i8** %arraydestroy.elementPast1, i64 -1
 486   %destroy_tmp1 = load i8*, i8** %arraydestroy.element1, align 8
 487   call void @llvm.objc.release(i8* %destroy_tmp1), !clang.imprecise_release !0
 488   %keys_ptr = getelementptr inbounds [2 x i8*], [2 x i8*]* %keys, i64 0, i64 0
 489   %arraydestroy.cmp1 = icmp eq i8** %arraydestroy.element1, %keys_ptr
 490   br i1 %arraydestroy.cmp1, label %arraydestroy.done1, label %arraydestroy.body1
 491
 492 arraydestroy.done1:
 493   call void @llvm.objc.release(i8* %call1), !clang.imprecise_release !0
 494   call void @llvm.objc.release(i8* %call1), !clang.imprecise_release !0
 495   ret void
 496 }
 497
 498 !0 = !{}
 499
 500 declare i32 @__gxx_personality_v0(...)