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