480 lines · plain
1; RUN: opt -passes=objc-arc -S < %s | FileCheck %s2 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 the29; retain is an objc_retainAutoreleasedReturnValue, since it's30; better to do the RV optimization.31 32; CHECK-LABEL: define void @test0(33; CHECK-NEXT: entry:34; CHECK-NEXT: %x = call ptr @returner35; 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 void41; 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 %return47 48t:49 call void @use_pointer(ptr %x)50 store i8 0, ptr %x51 br label %return52 53return:54 call void @llvm.objc.release(ptr %x) nounwind55 ret void56}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) ; TODO67 %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 void72}73 74; Delete a redundant retainRV,autoreleaseRV when forwaring a call result75; directly to a return value.76 77; CHECK-LABEL: define ptr @test3(78; CHECK: call ptr @returner()79; CHECK-NEXT: ret ptr %call80define ptr @test3() {81entry:82 %call = tail call ptr @returner()83 %0 = call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %call) nounwind84 %1 = call ptr @llvm.objc.autoreleaseReturnValue(ptr %0) nounwind85 ret ptr %186}87 88; Delete a redundant retain,autoreleaseRV when forwaring a call result89; directly to a return value.90 91; CHECK-LABEL: define ptr @test4(92; CHECK: call ptr @returner()93; CHECK-NEXT: ret ptr %call94define ptr @test4() {95entry:96 %call = call ptr @returner()97 %0 = call ptr @llvm.objc.retain(ptr %call) nounwind98 %1 = call ptr @llvm.objc.autoreleaseReturnValue(ptr %0) nounwind99 ret ptr %1100}101 102; Delete a redundant fused retain+autoreleaseRV when forwaring a call result103; directly to a return value.104 105; TODO106; HECK: define ptr @test5107; HECK: call ptr @returner()108; HECK-NEXT: ret ptr %call109;define ptr @test5() {110;entry:111; %call = call ptr @returner()112; %0 = call ptr @llvm.objc.retainAutoreleaseReturnValue(ptr %call) nounwind113; ret ptr %0114;}115 116; Don't eliminate objc_retainAutoreleasedReturnValue by merging it into117; an objc_autorelease.118; TODO? Merge objc_retainAutoreleasedReturnValue and objc_autorelease into119; objc_retainAutoreleasedReturnValueAutorelease and merge120; objc_retainAutoreleasedReturnValue and objc_autoreleaseReturnValue121; 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 %t133}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 %p144}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 %p153}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 %p161define 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 %p165}166 167; Don't do the autoreleaseRV optimization because @use_pointer168; 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 %p175define 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 %p180}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 %p189define 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 %p194}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 %p202define 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 %p208}209 210; Convert objc_retainAutoreleasedReturnValue to objc_retain if its211; 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 void216define void @test14(ptr %p) {217 call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %p)218 ret void219}220 221; Don't convert objc_retainAutoreleasedReturnValue to objc_retain if its222; 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 void228define void @test15() {229 %y = call ptr @returner()230 call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %y)231 ret void232}233 234; Delete autoreleaseRV+retainRV pairs.235 236; CHECK: define ptr @test19(ptr %p) {237; CHECK-NEXT: ret ptr %p238define ptr @test19(ptr %p) {239 call ptr @llvm.objc.autoreleaseReturnValue(ptr %p)240 call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %p)241 ret ptr %p242}243 244; Delete autoreleaseRV+retainRV pairs when they have equivalent PHIs as inputs245 246; CHECK: define ptr @test19phi(ptr %p) {247; CHECK-NEXT: entry:248; CHECK-NEXT: br label %test19bb249; CHECK: test19bb:250; CHECK-NEXT: ret ptr %p251define ptr @test19phi(ptr %p) {252entry:253 br label %test19bb254test19bb: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 %p260}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 %p268define ptr @test20(ptr %p) {269 call ptr @llvm.objc.autorelease(ptr %p)270 call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %p)271 ret ptr %p272}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 %p280define ptr @test21(ptr %p) {281 call ptr @llvm.objc.autoreleaseReturnValue(ptr %p)282 call ptr @llvm.objc.retain(ptr %p)283 ret ptr %p284}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 %p292define ptr @test22(ptr %p) {293 call ptr @llvm.objc.autorelease(ptr %p)294 call ptr @llvm.objc.retain(ptr %p)295 ret ptr %p296}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 %p304 call ptr @llvm.objc.autoreleaseReturnValue(ptr %p)305 ret void306}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 %p316}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_test25323; and the call to objc_retainAutoreleasedReturnValue, causing %second to be324; 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 !0337 call void @llvm.objc.release(ptr %first), !clang.imprecise_release !0338 ret void339}340 341; Check that ObjCARCOpt::OptimizeReturns removes the redundant calls even when342; they are not in the same basic block. This code used to cause an assertion343; failure.344 345; CHECK-LABEL: define ptr @test26()346; CHECK: call ptr @returner()347; CHECK-NOT: call348define ptr @test26() {349bb0:350 %v0 = call ptr @returner()351 %v1 = tail call ptr @llvm.objc.retain(ptr %v0)352 br label %bb1353bb1:354 %v2 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %v1)355 br label %bb2356bb2:357 ret ptr %v2358}359 360declare ptr @func27(i32);361 362; Check that ObjCARCOpt::OptimizeAutoreleaseRVCall doesn't turn a call to363; @llvm.objc.autoreleaseReturnValue into a call to @llvm.objc.autorelease when a return364; 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 %bb2376bb1:377 %v0 = call ptr @func27(i32 1)378 br label %bb3379bb2:380 %v2 = call ptr @func27(i32 2)381 br label %bb3382bb3: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 %retval387}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) nounwind399 %1 = call ptr @llvm.objc.autoreleaseReturnValue(ptr %0) nounwind400 ret ptr %1401}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 %lpad412 413invoke.cont:414 %1 = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %call)415 tail call void @llvm.objc.release(ptr %k), !clang.imprecise_release !0416 %2 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call)417 ret ptr %call418 419lpad:420 %3 = landingpad { ptr, i32 }421 cleanup422 tail call void @llvm.objc.release(ptr %k) #1, !clang.imprecise_release !0423 resume { ptr, i32 } %3424}425 426; The second retainRV/autoreleaseRV pair can be removed since the call to427; @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 %bb1439bb0: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 %v0444bb1: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 %v3449}450 451; Remove operand bundle "clang.arc.attachedcall" and the autoreleaseRV call if the call452; 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 %1463}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 %1475}476 477!0 = !{}478 479; CHECK: attributes [[NUW]] = { nounwind }480