llvm/ObjCARC: Eliminate inlined AutoreleaseRV calls

[dexonsmith]

Summary

Pair up inlined AutoreleaseRV calls with their matching RetainRV or
ClaimRV.

• For RetainRV, delete both instructions.
• For ClaimRV, replace with a normal Release and then run the usual optimizations.

This avoids problems where more aggressive inlining triggers memory
regressions.

[rjmccall]

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

681

"into a normal Release"

Please add something like assert(Class == ARCInstKind::ClaimRV); to make it clearer in the code why this is reasonable behavior.

llvm/test/Transforms/ObjCARC/inlined-autorelease-return-value.ll

115

Do you want to add a test for when there's any sort of interference besides just being in separate blocks? Or for when there are bitcasts?

[dexonsmith]

Added an assertion for clarity and fixed a comment.

[dexonsmith]

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

681

Fixed in the updated diff.

llvm/test/Transforms/ObjCARC/inlined-autorelease-return-value.ll

115

Yes, I'll add both of those. For interference, is it enough to put a call to llvm.objc.retain in between, or is there something else worth testing?

[rjmccall]

llvm/test/Transforms/ObjCARC/inlined-autorelease-return-value.ll

115

Maybe also an opaque call.

[dexonsmith]

Adding more testcases. The bitcast tests uncovered problems with the RAUW calls, which I also fixed.

[dexonsmith]

llvm/test/Transforms/ObjCARC/inlined-autorelease-return-value.ll

115

Please see elide_with_{retain,claim}RV_{bitcast,splitBy{Retain,Opaque}}.

[ahatanak]

It wasn't clear to me, but is the pair deleted only if there are no instructions that return false for isSafeBetweenRVCalls in between?

[dexonsmith]

Respond to Akira's feedback.

• Use isSafeBetweenRVCalls instead of skipping past all opaque calls.
• Delete the other user of isSafeBetweenRVCalls in ObjCARCOpt::OptimizeRetainRVCall, since the new code already covers those cases.
• Check for PHI node equivalence.

[dexonsmith]

In D70370#1750378, @ahatanak wrote:

It wasn't clear to me, but is the pair deleted only if there are no instructions that return false for isSafeBetweenRVCalls in between?

I thought it was okay to skip over all opaque calls, but I've changed the code to check for this.

[dexonsmith]

In D70370#1750591, @dexonsmith wrote:

In D70370#1750378, @ahatanak wrote:

It wasn't clear to me, but is the pair deleted only if there are no instructions that return false for isSafeBetweenRVCalls in between?

I thought it was okay to skip over all opaque calls, but I've changed the code to check for this.

I talked to @ahatanak in person and I believe we should compromise. I feel confident that skipping over non-ARC intrinsics and non-call/invoke instructions is safe. Skipping those is sufficient to skip any function teardown logic that the inliner could leave behind. Importantly, this will also catch intrinsics that get added to function epilogues in the future, without having to update a static list in the ARC optimizer.

While I suspect that skipping opaque function calls is also sound, I'm not as confident and it's not relevant in practice.

@ahatanak, you were going to keep thinking about this. Please confirm once you've had a chance to think it through.

@rjmccall, WDYT?

[ahatanak]

I think I agree with you. isSafeBetweenRVCalls seems too conservative. I can't think of a case where we aren't allowed to remove the pair of instructions because the instructions you listed exist between the pair (and that includes opaque calls). But John probably knows better whether that is safe or not.

[rjmccall]

The existence of *any* significant intervening code here indicates that either the optimizer moved it there (which is problematic but unfortunately possible with this representation) or that the caller+callee weren't actually paired and the optimization wouldn't have succeeded dynamically. Now, the ARC spec gives us some flexibility to try to avoid the autorelease anyway in the latter case; that does not actually have to be conditioned on seeing a retainARV/unsafeClaimARV, because ARC just says that it will ensure that the value is still valid when the caller gets it and that the caller shouldn't assume that the value is in the autorelease pool. But it's definitely odder territory.

[dexonsmith]

@rjmccall gave me an LGTM offline.

[dexonsmith]

Pushed as 3279724905c14a8db383ade53af40a0dd49504d8.

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

class ObjCARCOpt : public FunctionPass {
     /// Flags which determine whether each of the interesting runtime functions
     /// is in fact used in the current function.
     unsigned UsedInThisFunction;
 
     bool OptimizeRetainRVCall(Function &F, Instruction *RetainRV);
     void OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV,
                                    ARCInstKind &Class);
     void OptimizeIndividualCalls(Function &F);
-    void
-    OptimizeIndividualCallImpl(Function &F,
-                               DenseMap<BasicBlock *, ColorVector> &BlockColors,
-                               Instruction *Inst, ARCInstKind Class);
+
+    /// Optimize an individual call, optionally passing the
+    /// GetArgRCIdentityRoot if it has already been computed.
+    void OptimizeIndividualCallImpl(
+        Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
+        Instruction *Inst, ARCInstKind Class, const Value *Arg);
+
+    /// Try to optimize an AutoreleaseRV with a RetainRV or ClaimRV.  If the
+    /// optimization occurs, returns true to indicate that the caller should
+    /// assume the instructions are dead.
+    bool OptimizeInlinedAutoreleaseRVCall(
+        Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
+        Instruction *Inst, const Value *&Arg, ARCInstKind Class,
+        Instruction *AutoreleaseRV, const Value *&AutoreleaseRVArg);
 
     void CheckForCFGHazards(const BasicBlock *BB,
                             DenseMap<const BasicBlock *, BBState> &BBStates,
                             BBState &MyStates) const;
     bool VisitInstructionBottomUp(Instruction *Inst, BasicBlock *BB,
                                   BlotMapVector<Value *, RRInfo> &Retains,
                                   BBState &MyStates);
     bool VisitBottomUp(BasicBlock *BB,

 
 void ObjCARCOpt::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<ObjCARCAAWrapperPass>();
   AU.addRequired<AAResultsWrapperPass>();
   // ARC optimization doesn't currently split critical edges.
   AU.setPreservesCFG();
 }
 
-static bool isSafeBetweenRVCalls(const Instruction *I) {
-  if (IsNoopInstruction(I))
-    return true;
-
-  auto *CB = dyn_cast<CallBase>(I);
-  if (!CB)
-    return false;
-
-  Intrinsic::ID IID = CB->getIntrinsicID();
-  if (IID == Intrinsic::not_intrinsic)
-    return false;
-
-  switch (IID) {
-  case Intrinsic::lifetime_start:
-  case Intrinsic::lifetime_end:
-    // The inliner adds new lifetime markers as part of the return sequence,
-    // which should be skipped when looking for paired return RV call.
-    LLVM_FALLTHROUGH;
-  case Intrinsic::stacksave:
-  case Intrinsic::stackrestore:
-    // If the inlined code contains dynamic allocas, the above applies as well.
-    return true;
-  default:
-    return false;
-  }
-}
-
 /// Turn objc_retainAutoreleasedReturnValue into objc_retain if the operand is
-/// not a return value.  Or, if it can be paired with an
-/// objc_autoreleaseReturnValue, delete the pair and return true.
+/// not a return value.
 bool
 ObjCARCOpt::OptimizeRetainRVCall(Function &F, Instruction *RetainRV) {
   // Check for the argument being from an immediately preceding call or invoke.
   const Value *Arg = GetArgRCIdentityRoot(RetainRV);
   ImmutableCallSite CS(Arg);
   if (const Instruction *Call = CS.getInstruction()) {
     if (Call->getParent() == RetainRV->getParent()) {
       BasicBlock::const_iterator I(Call);
if (Call->getParent() == RetainRV->getParent()) {
         while (IsNoopInstruction(&*I))
           ++I;
         if (&*I == RetainRV)
           return false;
       }
     }
   }
 
-  // Track PHIs which are equivalent to our Arg.
-  SmallDenseSet<const Value*, 2> EquivalentArgs;
-  EquivalentArgs.insert(Arg);
-
-  // Add PHIs that are equivalent to Arg to ArgUsers.
-  if (const PHINode *PN = dyn_cast<PHINode>(Arg)) {
-    SmallVector<const Value *, 2> ArgUsers;
-    getEquivalentPHIs(*PN, ArgUsers);
-    EquivalentArgs.insert(ArgUsers.begin(), ArgUsers.end());
-  }
-
-  // Check for being preceded by an objc_autoreleaseReturnValue on the same
-  // pointer. In this case, we can delete the pair.
-  BasicBlock::iterator I = RetainRV->getIterator(),
-                       Begin = RetainRV->getParent()->begin();
-  if (I != Begin) {
-    do
-      --I;
-    while (I != Begin && isSafeBetweenRVCalls(&*I));
-    if (GetBasicARCInstKind(&*I) == ARCInstKind::AutoreleaseRV &&
-        EquivalentArgs.count(GetArgRCIdentityRoot(&*I))) {
-      Changed = true;
-      ++NumPeeps;
-
-      LLVM_DEBUG(dbgs() << "Erasing autoreleaseRV,retainRV pair: " << *I << "\n"
-                        << "Erasing " << *RetainRV << "\n");
-
-      EraseInstruction(&*I);
-      EraseInstruction(RetainRV);
-      return true;
-    }
-  }
-
   // Turn it to a plain objc_retain.
   Changed = true;
   ++NumPeeps;
 
   LLVM_DEBUG(dbgs() << "Transforming objc_retainAutoreleasedReturnValue => "
                        "objc_retain since the operand is not a return value.\n"
                        "Old = "
                     << *RetainRV << "\n");
 
   Function *NewDecl = EP.get(ARCRuntimeEntryPointKind::Retain);
   cast<CallInst>(RetainRV)->setCalledFunction(NewDecl);
 
   LLVM_DEBUG(dbgs() << "New = " << *RetainRV << "\n");
 
   return false;
 }
 
+bool ObjCARCOpt::OptimizeInlinedAutoreleaseRVCall(
+    Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
+    Instruction *Inst, const Value *&Arg, ARCInstKind Class,
+    Instruction *AutoreleaseRV, const Value *&AutoreleaseRVArg) {
+  // Must be in the same basic block.
+  assert(Inst->getParent() == AutoreleaseRV->getParent());
+
+  // Must operate on the same root.
+  Arg = GetArgRCIdentityRoot(Inst);
+  AutoreleaseRVArg = GetArgRCIdentityRoot(AutoreleaseRV);
+  if (Arg != AutoreleaseRVArg) {
+    // If there isn't an exact match, check if we have equivalent PHIs.
+    const PHINode *PN = dyn_cast<PHINode>(Arg);
+    if (!PN)
+      return false;
+
+    SmallVector<const Value *, 4> ArgUsers;
+    getEquivalentPHIs(*PN, ArgUsers);
+    if (llvm::find(ArgUsers, AutoreleaseRVArg) == ArgUsers.end())
+      return false;
+  }
+
+  // Okay, this is a match.  Merge them.
+  ++NumPeeps;
+  LLVM_DEBUG(dbgs() << "Found inlined objc_autoreleaseReturnValue '"
+                    << *AutoreleaseRV << "' paired with '" << *Inst << "'\n");
+
+  // Delete the RV pair, starting with the AutoreleaseRV.
+  AutoreleaseRV->replaceAllUsesWith(
+      cast<CallInst>(AutoreleaseRV)->getArgOperand(0));
+  EraseInstruction(AutoreleaseRV);
+  if (Class == ARCInstKind::RetainRV) {
+    // AutoreleaseRV and RetainRV cancel out.  Delete the RetainRV.
+    Inst->replaceAllUsesWith(cast<CallInst>(Inst)->getArgOperand(0));
+    EraseInstruction(Inst);
+    return true;
+  }
+
+  // ClaimRV is a frontend peephole for RetainRV + Release.  Since the
+  // AutoreleaseRV and RetainRV cancel out, replace the ClaimRV with a Release.
+  assert(Class == ARCInstKind::ClaimRV);
+  Value *CallArg = cast<CallInst>(Inst)->getArgOperand(0);
+  CallInst *Release = CallInst::Create(
+      EP.get(ARCRuntimeEntryPointKind::Release), CallArg, "", Inst);
+  assert(IsAlwaysTail(ARCInstKind::ClaimRV) &&
+         "Expected ClaimRV to be safe to tail call");
+  Release->setTailCall();
+  Inst->replaceAllUsesWith(CallArg);
+  EraseInstruction(Inst);
+
+  // Run the normal optimizations on Release.
+  OptimizeIndividualCallImpl(F, BlockColors, Release, ARCInstKind::Release,
+                             Arg);
+  return true;
+}
+
 /// Turn objc_autoreleaseReturnValue into objc_autorelease if the result is not
 /// used as a return value.
 void ObjCARCOpt::OptimizeAutoreleaseRVCall(Function &F,
                                            Instruction *AutoreleaseRV,
                                            ARCInstKind &Class) {
   // Check for a return of the pointer value.
   const Value *Ptr = GetArgRCIdentityRoot(AutoreleaseRV);
 
void ObjCARCOpt::OptimizeIndividualCalls(Function &F) {
   // Reset all the flags in preparation for recomputing them.
   UsedInThisFunction = 0;
 
   DenseMap<BasicBlock *, ColorVector> BlockColors;
   if (F.hasPersonalityFn() &&
       isScopedEHPersonality(classifyEHPersonality(F.getPersonalityFn())))
     BlockColors = colorEHFunclets(F);
 
+  // Store any delayed AutoreleaseRV intrinsics, so they can be easily paired
+  // with RetainRV and ClaimRV.
+  Instruction *DelayedAutoreleaseRV = nullptr;
+  const Value *DelayedAutoreleaseRVArg = nullptr;
+  auto setDelayedAutoreleaseRV = [&](Instruction *AutoreleaseRV) {
+    assert(!DelayedAutoreleaseRV || !AutoreleaseRV);
+    DelayedAutoreleaseRV = AutoreleaseRV;
+    DelayedAutoreleaseRVArg = nullptr;
+  };
+  auto optimizeDelayedAutoreleaseRV = [&]() {
+    if (!DelayedAutoreleaseRV)
+      return;
+    OptimizeIndividualCallImpl(F, BlockColors, DelayedAutoreleaseRV,
+                               ARCInstKind::AutoreleaseRV,
+                               DelayedAutoreleaseRVArg);
+    setDelayedAutoreleaseRV(nullptr);
+  };
+  auto shouldDelayAutoreleaseRV = [&](Instruction *NonARCInst) {
+    // Nothing to delay, but we may as well skip the logic below.
+    if (!DelayedAutoreleaseRV)
+      return true;
+
+    // If we hit the end of the basic block we're not going to find an RV-pair.
+    // Stop delaying.
+    if (NonARCInst->isTerminator())
+      return false;
+
+    // Given the frontend rules for emitting AutoreleaseRV, RetainRV, and
+    // ClaimRV, it's probably safe to skip over even opaque function calls
+    // here since OptimizeInlinedAutoreleaseRVCall will confirm that they
+    // have the same RCIdentityRoot.  However, what really matters is
+    // skipping instructions or intrinsics that the inliner could leave behind;
+    // be conservative for now and don't skip over opaque calls, which could
+    // potentially include other ARC calls.
+    auto *CB = dyn_cast<CallBase>(NonARCInst);
+    if (!CB)
+      return true;
+    return CB->getIntrinsicID() != Intrinsic::not_intrinsic;
+  };
+
   // Visit all objc_* calls in F.
   for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
     Instruction *Inst = &*I++;
 
     ARCInstKind Class = GetBasicARCInstKind(Inst);
 
-    LLVM_DEBUG(dbgs() << "Visiting: Class: " << Class << "; " << *Inst << "\n");
-
     // Skip this loop if this instruction isn't itself an ARC intrinsic.
+    const Value *Arg = nullptr;
     switch (Class) {
     default:
+      optimizeDelayedAutoreleaseRV();
       break;
     case ARCInstKind::CallOrUser:
     case ARCInstKind::User:
     case ARCInstKind::None:
+      // This is a non-ARC instruction.  If we're delaying an AutoreleaseRV,
+      // check if it's safe to skip over it; if not, optimize the AutoreleaseRV
+      // now.
+      if (!shouldDelayAutoreleaseRV(Inst))
+        optimizeDelayedAutoreleaseRV();
       continue;
+    case ARCInstKind::AutoreleaseRV:
+      optimizeDelayedAutoreleaseRV();
+      setDelayedAutoreleaseRV(Inst);
+      continue;
+    case ARCInstKind::RetainRV:
+    case ARCInstKind::ClaimRV:
+      if (DelayedAutoreleaseRV) {
+        // We have a potential RV pair.  Check if they cancel out.
+        if (OptimizeInlinedAutoreleaseRVCall(F, BlockColors, Inst, Arg, Class,
+                                             DelayedAutoreleaseRV,
+                                             DelayedAutoreleaseRVArg)) {
+          setDelayedAutoreleaseRV(nullptr);
+          continue;
+        }
+        optimizeDelayedAutoreleaseRV();
+      }
+      break;
     }
 
-    OptimizeIndividualCallImpl(F, BlockColors, Inst, Class);
+    OptimizeIndividualCallImpl(F, BlockColors, Inst, Class, Arg);
   }
+
+  // Catch the final delayed AutoreleaseRV.
+  optimizeDelayedAutoreleaseRV();
 }
 
 void ObjCARCOpt::OptimizeIndividualCallImpl(
     Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
-    Instruction *Inst, ARCInstKind Class) {
+    Instruction *Inst, ARCInstKind Class, const Value *Arg) {
+  LLVM_DEBUG(dbgs() << "Visiting: Class: " << Class << "; " << *Inst << "\n");
+
   // Some of the ARC calls can be deleted if their arguments are global
   // variables that are inert in ARC.
   if (IsNoopOnGlobal(Class)) {
     Value *Opnd = Inst->getOperand(0);
     if (auto *GV = dyn_cast<GlobalVariable>(Opnd->stripPointerCasts()))
       if (GV->hasAttribute("objc_arc_inert")) {
         if (!Inst->getType()->isVoidTy())
           Inst->replaceAllUsesWith(Opnd);
void ObjCARCOpt::OptimizeIndividualCallImpl(
   }
 
   // Note: This catches instructions unrelated to ARC.
   if (!IsNoopOnNull(Class)) {
     UsedInThisFunction |= 1 << unsigned(Class);
     return;
   }
 
-  const Value *Arg = GetArgRCIdentityRoot(Inst);
+  // If we haven't already looked up the root, look it up now.
+  if (!Arg)
+    Arg = GetArgRCIdentityRoot(Inst);
 
   // ARC calls with null are no-ops. Delete them.
   if (IsNullOrUndef(Arg)) {
     Changed = true;
     ++NumNoops;
     LLVM_DEBUG(dbgs() << "ARC calls with  null are no-ops. Erasing: " << *Inst
                       << "\n");
     EraseInstruction(Inst);

llvm/test/Transforms/ObjCARC/inlined-autorelease-return-value.ll

+; RUN: opt -basicaa -objc-arc -S < %s | FileCheck %s
+
+target datalayout = "e-p:64:64:64"
+
+declare i8* @llvm.objc.retain(i8*)
+declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
+declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
+declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
+declare void @opaque()
+declare void @llvm.lifetime.start(i64, i8* nocapture)
+declare void @llvm.lifetime.end(i64, i8* nocapture)
+
+; CHECK-LABEL: define i8* @elide_with_retainRV(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i8* %x
+define i8* @elide_with_retainRV(i8* %x) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_bitcast(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %c = bitcast i32* %x to i8*
+; CHECK-NEXT:    ret i8* %c
+define i8* @elide_with_retainRV_bitcast(i32* %x) nounwind {
+entry:
+  %a = bitcast i32* %x to i8*
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %a) nounwind
+  %c = bitcast i32* %x to i8*
+  %d = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %c) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_phi(
+; CHECK-NOT:   define
+; CHECK:       phis:
+; CHECK-NEXT:    phi i8*
+; CHECK-NEXT:    ret i8*
+define i8* @elide_with_retainRV_phi(i8* %x) nounwind {
+entry:
+  br label %phis
+
+phis:
+  %a = phi i8* [ %x, %entry ]
+  %c = phi i8* [ %x, %entry ]
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %a) nounwind
+  %d = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %c) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_splitByRetain(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %b = call i8* @llvm.objc.autorelease(i8* %x)
+; CHECK-NEXT:    tail call i8* @llvm.objc.retain(i8* %x)
+; CHECK-NEXT:    tail call i8* @llvm.objc.retain(i8* %b)
+define i8* @elide_with_retainRV_splitByRetain(i8* %x) nounwind {
+entry:
+  ; Cleanup is blocked by other ARC intrinsics for ease of implementation; we
+  ; only delay processing AutoreleaseRV until the very next ARC intrinsic.  In
+  ; practice, it would be very strange for this to matter.
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.retain(i8* %x) nounwind
+  %d = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_splitByOpaque(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %b = call i8* @llvm.objc.autorelease(i8* %x)
+; CHECK-NEXT:    call void @opaque()
+; CHECK-NEXT:    %d = tail call i8* @llvm.objc.retain(i8* %b)
+; CHECK-NEXT:    ret i8* %d
+define i8* @elide_with_retainRV_splitByOpaque(i8* %x) nounwind {
+entry:
+  ; Cleanup should get blocked by opaque calls.
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  call void @opaque() nounwind
+  %d = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_splitByLifetime(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 8, i8* %x)
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 8, i8* %x)
+; CHECK-NEXT:    ret i8* %x
+define i8* @elide_with_retainRV_splitByLifetime(i8* %x) nounwind {
+entry:
+  ; Cleanup should skip over lifetime intrinsics.
+  call void @llvm.lifetime.start(i64 8, i8* %x)
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  call void @llvm.lifetime.end(i64 8, i8* %x)
+  %d = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_wrongArg(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @llvm.objc.release(i8* %x)
+; CHECK-NEXT:    tail call i8* @llvm.objc.retain(i8* %y)
+define i8* @elide_with_retainRV_wrongArg(i8* %x, i8* %y) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %y) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_wrongBB(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call i8* @llvm.objc.autorelease(i8* %x)
+; CHECK-NEXT:    br label %next
+; CHECK:       next:
+; CHECK-NEXT:    tail call i8* @llvm.objc.retain(
+; CHECK-NEXT:    ret i8*
+define i8* @elide_with_retainRV_wrongBB(i8* %x) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  br label %next
+
+next:
+  %c = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_beforeAutoreleaseRV(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %x)
+; CHECK-NEXT:    ret i8* %x
+define i8* @elide_with_retainRV_beforeAutoreleaseRV(i8* %x) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %b) nounwind
+  %d = call i8* @llvm.objc.autoreleaseReturnValue(i8* %c) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_retainRV_afterRetain(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    tail call i8* @llvm.objc.retain(i8* %x)
+; CHECK-NEXT:    ret i8* %a
+define i8* @elide_with_retainRV_afterRetain(i8* %x) nounwind {
+entry:
+  %a = call i8* @llvm.objc.retain(i8* %x) nounwind
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %a) nounwind
+  %c = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    tail call void @llvm.objc.release(i8* %x)
+; CHECK-NEXT:    ret i8* %x
+define i8* @elide_with_claimRV(i8* %x) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_bitcast(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %c = bitcast i32* %x to i8*
+; CHECK-NEXT:    tail call void @llvm.objc.release(i8* %c)
+; CHECK-NEXT:    ret i8* %c
+define i8* @elide_with_claimRV_bitcast(i32* %x) nounwind {
+entry:
+  %a = bitcast i32* %x to i8*
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %a) nounwind
+  %c = bitcast i32* %x to i8*
+  %d = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %c) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_phi(
+; CHECK-NOT:   define
+; CHECK:       phis:
+; CHECK-NEXT:    %c = phi i8*
+; CHECK-NEXT:    tail call void @llvm.objc.release(i8* %c)
+; CHECK-NEXT:    ret i8* %c
+define i8* @elide_with_claimRV_phi(i8* %x) nounwind {
+entry:
+  br label %phis
+
+phis:
+  %a = phi i8* [ %x, %entry ]
+  %c = phi i8* [ %x, %entry ]
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %a) nounwind
+  %d = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %c) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_splitByRetain(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %b = call i8* @llvm.objc.autorelease(i8* %x)
+; CHECK-NEXT:    tail call i8* @llvm.objc.retain(i8* %x)
+; CHECK-NEXT:    tail call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b)
+define i8* @elide_with_claimRV_splitByRetain(i8* %x) nounwind {
+entry:
+  ; Cleanup is blocked by other ARC intrinsics for ease of implementation; we
+  ; only delay processing AutoreleaseRV until the very next ARC intrinsic.  In
+  ; practice, it would be very strange for this to matter.
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.retain(i8* %x) nounwind
+  %d = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_splitByOpaque(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %b = call i8* @llvm.objc.autorelease(i8* %x)
+; CHECK-NEXT:    call void @opaque()
+; CHECK-NEXT:    %d = tail call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b)
+; CHECK-NEXT:    ret i8* %d
+define i8* @elide_with_claimRV_splitByOpaque(i8* %x) nounwind {
+entry:
+  ; Cleanup should get blocked by opaque calls.
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  call void @opaque() nounwind
+  %d = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_splitByLifetime(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 8, i8* %x)
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 8, i8* %x)
+; CHECK-NEXT:    tail call void @llvm.objc.release(i8* %x)
+; CHECK-NEXT:    ret i8* %x
+define i8* @elide_with_claimRV_splitByLifetime(i8* %x) nounwind {
+entry:
+  ; Cleanup should skip over lifetime intrinsics.
+  call void @llvm.lifetime.start(i64 8, i8* %x)
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  call void @llvm.lifetime.end(i64 8, i8* %x)
+  %d = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %d
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_wrongArg(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @llvm.objc.release(i8* %x)
+; CHECK-NEXT:    tail call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %y)
+define i8* @elide_with_claimRV_wrongArg(i8* %x, i8* %y) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %y) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_wrongBB(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call i8* @llvm.objc.autorelease(i8* %x)
+; CHECK-NEXT:    br label %next
+; CHECK:       next:
+; CHECK-NEXT:    tail call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(
+; CHECK-NEXT:    ret i8*
+define i8* @elide_with_claimRV_wrongBB(i8* %x) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  br label %next
+
+next:
+  %c = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %c
+}
+
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_beforeAutoreleaseRV(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    tail call void @llvm.objc.release(i8* %x)
+; CHECK-NEXT:    tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %x)
+; CHECK-NEXT:    ret i8* %x
+define i8* @elide_with_claimRV_beforeAutoreleaseRV(i8* %x) nounwind {
+entry:
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %x) nounwind
+  %c = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b) nounwind
+  %d = call i8* @llvm.objc.autoreleaseReturnValue(i8* %c) nounwind
+  ret i8* %c
+}
+
+; CHECK-LABEL: define i8* @elide_with_claimRV_afterRetain(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i8* %x
+define i8* @elide_with_claimRV_afterRetain(i8* %x) nounwind {
+entry:
+  %a = call i8* @llvm.objc.retain(i8* %x) nounwind
+  %b = call i8* @llvm.objc.autoreleaseReturnValue(i8* %a) nounwind
+  %c = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %b) nounwind
+  ret i8* %c
+}

llvm/test/Transforms/ObjCARC/unsafe-claim-rv.ll

if.end:                                           ; preds = %if.then, %entry
   %2 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %Y.0)
   %3 = tail call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %2)
   tail call void @llvm.objc.release(i8* %0) 
   ret void
 }
 
 ; CHECK: if.then
 ; CHECK: tail call i8* @llvm.objc.retain
-; CHECK-NEXT: call i8* @llvm.objc.autorelease
 ; CHECK: %Y.0 = phi
-; CHECK-NEXT: tail call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %Y.0)
+; CHECK-NEXT: tail call void @llvm.objc.release
 ; CHECK-NEXT: tail call void @llvm.objc.release