[ObjC][ARC] Use the addresses of the ARC runtime functions instead of integer 0/1 for the operand of bundle "clang.arc.attachedcall"

[ahatanak]

Summary

https://reviews.llvm.org/D102996 changes the operand of bundle "clang.arc.attachedcall". This patch makes changes to llvm that are needed to handle the new IR.

This should make it easier to understand what the IR is doing and also simplify some of the passes as they no longer have to translate the integer values to the runtime functions.

llvm/docs/LangRef.rst

 :ref:`stackmap entry <statepoint-stackmap-format>`.  See the intrinsic description
 for further details.
 
 ObjC ARC Attached Call Operand Bundles
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 A ``"clang.arc.attachedcall`` operand bundle on a call indicates the call is
 implicitly followed by a marker instruction and a call to an ObjC runtime
-function that uses the result of the call. If the argument passed to the operand
-bundle is 0, ``@objc_retainAutoreleasedReturnValue`` is called. If 1 is passed,
-``@objc_unsafeClaimAutoreleasedReturnValue`` is called. A call with this bundle
-implicitly uses its return value.
+function that uses the result of the call. The operand of the bundle is either
+the pointer to the runtime function (``@objc_retainAutoreleasedReturnValue`` or
+``@objc_unsafeClaimAutoreleasedReturnValue``) or null. A null operand indicates
+the marker instruction has to be emitted after the call but calls to the runtime
+functions don't have to be emitted since they already have been emitted. A call
+with this bundle implicitly uses its return value.
 
 The operand bundle is needed to ensure the call is immediately followed by the
 marker instruction or the ObjC runtime call in the final output.
 
 .. _moduleasm:
 
 Module-Level Inline Assembly
 ----------------------------

llvm/include/llvm/Analysis/ObjCARCUtil.h

 //===- ObjCARCUtil.h - ObjC ARC Utility Functions ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// This file defines ARC utility functions which are used by various parts of
 /// the compiler.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_OBJCARCUTIL_H
 #define LLVM_IR_OBJCARCUTIL_H
 
+#include "llvm/Analysis/ObjCARCInstKind.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/LLVMContext.h"
 
 namespace llvm {
 namespace objcarc {
 
 inline const char *getRVMarkerModuleFlagStr() {
   return "clang.arc.retainAutoreleasedReturnValueMarker";
 }
 
-enum AttachedCallOperandBundle : unsigned { RVOB_Retain, RVOB_Claim };
+/// This function checks whether a call has operand bundle
+/// clang_arc_attachedcall and returns the pointer to the ARC runtime function.
+inline std::pair<bool, Function *> getAttachedARCFunction(const CallBase *CB) {
+  auto B = CB->getOperandBundle(LLVMContext::OB_clang_arc_attachedcall);
+  if (!B.hasValue())
+    return {false, nullptr};
+
+  if (B->Inputs.size() == 0)
+    return {true, nullptr};
 
-inline AttachedCallOperandBundle
-getAttachedCallOperandBundleEnum(bool IsRetain) {
-  return IsRetain ? RVOB_Retain : RVOB_Claim;
+  return {true, cast<Function>(B->Inputs[0])};
 }
 
-inline bool hasAttachedCallOpBundle(const CallBase *CB, bool IsRetain) {
-  auto B = CB->getOperandBundle(LLVMContext::OB_clang_arc_attachedcall);
-  if (!B.hasValue())
-    return false;
-  return cast<ConstantInt>(B->Inputs[0])->getZExtValue() ==
-         getAttachedCallOperandBundleEnum(IsRetain);
+/// This function returns the ARCInstKind of the function attached to operand
+/// bundle clang_arc_attachedcall. It returns None if the call doesn't have the
+/// operand bundle or the operand is null. Otherwise it returns either RetainRV
+/// or ClaimRV.
+inline ARCInstKind getAttachedARCFunctionKind(const CallBase *CB) {
+  std::pair<bool, Function *> P = getAttachedARCFunction(CB);
+  if (!P.first || !P.second)
+    return ARCInstKind::None;
+  auto FnClass = GetFunctionClass(P.second);
+  assert(
+      (FnClass == ARCInstKind::RetainRV || FnClass == ARCInstKind::ClaimRV) &&
+      "unexpected ARC runtime function");
+  return FnClass;
 }
 
 inline bool hasAttachedCallOpBundle(const CallBase *CB) {
   return CB->getOperandBundle(LLVMContext::OB_clang_arc_attachedcall)
       .hasValue();
 }
 
 } // end namespace objcarc
 } // end namespace llvm
 
 #endif

llvm/lib/IR/Verifier.cpp

for (const auto &I : MDs) {
       visitMDNode(*I.second, AllowLocs);
     }
   }
 
   // If this function is actually an intrinsic, verify that it is only used in
   // direct call/invokes, never having its "address taken".
   // Only do this if the module is materialized, otherwise we don't have all the
   // uses.
-  if (F.getIntrinsicID() && F.getParent()->isMaterialized()) {
+  Intrinsic::ID IID = F.getIntrinsicID();
+  if (IID && F.getParent()->isMaterialized()) {
     const User *U;
-    if (F.hasAddressTaken(&U))
+    if (F.hasAddressTaken(&U) &&
+        IID != Intrinsic::objc_retainAutoreleasedReturnValue &&
+        IID != Intrinsic::objc_unsafeClaimAutoreleasedReturnValue)
       Assert(false, "Invalid user of intrinsic instruction!", U);
   }
 
   auto *N = F.getSubprogram();
   HasDebugInfo = (N != nullptr);
   if (!HasDebugInfo)
     return;
 
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
 
     // Check to make sure that only first-class-values are operands to
     // instructions.
     if (!I.getOperand(i)->getType()->isFirstClassType()) {
       Assert(false, "Instruction operands must be first-class values!", &I);
     }
 
     if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
+      // This code checks whether the function is a retainRV/claimRV intrinsic
+      // whose address is used as the operand of a clang_arc_attachedcall
+      // operand bundle.
+      auto IsAttachedCallOperand = [](Function *F, const CallBase *CBI,
+                                      int Idx) {
+        Intrinsic::ID IID = F->getIntrinsicID();
+        return CBI &&
+               (IID == Intrinsic::objc_retainAutoreleasedReturnValue ||
+                IID == Intrinsic::objc_unsafeClaimAutoreleasedReturnValue) &&
+               CBI->isBundleOperand(Idx) &&
+               CBI->getOperandBundleForOperand(Idx).getTagID() ==
+                   LLVMContext::OB_clang_arc_attachedcall;
+      };
+
       // Check to make sure that the "address of" an intrinsic function is never
-      // taken.
-      Assert(!F->isIntrinsic() ||
-                 (CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i)),
+      // taken except when the intrinsic is objc_retainAutoreleasedReturnValue
+      // or objc_unsafeClaimAutoreleasedReturnValue.
+      Assert((!F->isIntrinsic() ||
+              (CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i)) ||
+              IsAttachedCallOperand(F, CBI, i)),
              "Cannot take the address of an intrinsic!", &I);
       Assert(
           !F->isIntrinsic() || isa<CallInst>(I) ||
               F->getIntrinsicID() == Intrinsic::donothing ||
               F->getIntrinsicID() == Intrinsic::seh_try_begin ||
               F->getIntrinsicID() == Intrinsic::seh_try_end ||
               F->getIntrinsicID() == Intrinsic::seh_scope_begin ||
               F->getIntrinsicID() == Intrinsic::seh_scope_end ||
               F->getIntrinsicID() == Intrinsic::coro_resume ||
               F->getIntrinsicID() == Intrinsic::coro_destroy ||
               F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void ||
               F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 ||
               F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint ||
-              F->getIntrinsicID() == Intrinsic::wasm_rethrow,
+              F->getIntrinsicID() == Intrinsic::wasm_rethrow ||
+              IsAttachedCallOperand(F, CBI, i),
           "Cannot invoke an intrinsic other than donothing, patchpoint, "
           "statepoint, coro_resume or coro_destroy",
           &I);
       Assert(F->getParent() == &M, "Referencing function in another module!",
              &I, &M, F, F->getParent());
     } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
       Assert(OpBB->getParent() == BB->getParent(),
              "Referring to a basic block in another function!", &I);

llvm/lib/Target/X86/X86ISelLowering.cpp

if (HasNoCfCheck && IsCFProtectionSupported && IsIndirectCall) {
     assert(!isTailCall &&
            "tail calls cannot be marked with clang.arc.attachedcall");
     assert(Is64Bit && "clang.arc.attachedcall is only supported in 64bit mode");
 
     // Add target constant to select ObjC runtime call just before the call
     // target. RuntimeCallType == 0 selects objc_retainAutoreleasedReturnValue,
     // RuntimeCallType == 0 selects objc_unsafeClaimAutoreleasedReturnValue when
     // epxanding the pseudo.
+    Function *ARCFn = objcarc::getAttachedARCFunction(CLI.CB).second;
+    Module *M = MF.getFunction().getParent();
+    assert(
+        ARCFn &&
+        (ARCFn == M->getFunction("objc_retainAutoreleasedReturnValue") ||
+         ARCFn == M->getFunction("objc_unsafeClaimAutoreleasedReturnValue")) &&
+        "unexpected ARC function");
     unsigned RuntimeCallType =
-        objcarc::hasAttachedCallOpBundle(CLI.CB, true) ? 0 : 1;
+        ARCFn == M->getFunction("objc_retainAutoreleasedReturnValue") ? 0 : 1;
     Ops.insert(Ops.begin() + 1,
                DAG.getTargetConstant(RuntimeCallType, dl, MVT::i32));
     Chain = DAG.getNode(X86ISD::CALL_RVMARKER, dl, NodeTys, Ops);
   } else {
     Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, Ops);
   }
 
   InFlag = Chain.getValue(1);

llvm/lib/Transforms/ObjCARC/ObjCARC.h

 /// going to be removed from the IR before WinEHPrepare.
 CallInst *createCallInstWithColors(
     FunctionCallee Func, ArrayRef<Value *> Args, const Twine &NameStr,
     Instruction *InsertBefore,
     const DenseMap<BasicBlock *, ColorVector> &BlockColors);
 
 class BundledRetainClaimRVs {
 public:
-  BundledRetainClaimRVs(ARCRuntimeEntryPoints &P, bool ContractPass)
-      : EP(P), ContractPass(ContractPass) {}
+  BundledRetainClaimRVs(bool ContractPass) : ContractPass(ContractPass) {}
   ~BundledRetainClaimRVs();
 
   /// Insert a retainRV/claimRV call to the normal destination blocks of invokes
   /// with operand bundle "clang.arc.attachedcall". If the edge to the normal
   /// destination block is a critical edge, split it.
   std::pair<bool, bool> insertAfterInvokes(Function &F, DominatorTree *DT);
 
   /// Insert a retainRV/claimRV call.
void eraseInst(CallInst *CI) {
     }
     EraseInstruction(CI);
   }
 
 private:
   /// A map of inserted retainRV/claimRV calls to annotated calls/invokes.
   DenseMap<CallInst *, CallBase *> RVCalls;
 
-  ARCRuntimeEntryPoints &EP;
   bool ContractPass;
 };
 
 } // end namespace objcarc
 } // end namespace llvm
 
 #endif

llvm/lib/Transforms/ObjCARC/ObjCARC.cpp

CallInst *BundledRetainClaimRVs::insertRVCall(Instruction *InsertPt,
   DenseMap<BasicBlock *, ColorVector> BlockColors;
   return insertRVCallWithColors(InsertPt, AnnotatedCall, BlockColors);
 }
 
 CallInst *BundledRetainClaimRVs::insertRVCallWithColors(
     Instruction *InsertPt, CallBase *AnnotatedCall,
     const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
   IRBuilder<> Builder(InsertPt);
-  bool IsRetainRV = objcarc::hasAttachedCallOpBundle(AnnotatedCall, true);
-  Function *Func = EP.get(IsRetainRV ? ARCRuntimeEntryPointKind::RetainRV
-                                     : ARCRuntimeEntryPointKind::ClaimRV);
+  Function *Func = objcarc::getAttachedARCFunction(AnnotatedCall).second;
+  assert(Func && "operand isn't a Function");
   Type *ParamTy = Func->getArg(0)->getType();
   Value *CallArg = Builder.CreateBitCast(AnnotatedCall, ParamTy);
   auto *Call =
       createCallInstWithColors(Func, CallArg, "", InsertPt, BlockColors);
   RVCalls[Call] = AnnotatedCall;
   return Call;
 }
 
 BundledRetainClaimRVs::~BundledRetainClaimRVs() {
   if (ContractPass) {
-    // At this point, we know that the annotated calls can't be tail calls as
-    // they are followed by marker instructions and retainRV/claimRV calls. Mark
-    // them as notail, so that the backend knows these calls can't be tail
-    // calls.
-    for (auto P : RVCalls)
-      if (auto *CI = dyn_cast<CallInst>(P.second))
+    for (auto P : RVCalls) {
+      CallBase *CB = P.second;
+      // At this point, we know that the annotated calls can't be tail calls
+      // as they are followed by marker instructions and retainRV/claimRV
+      // calls. Mark them as notail so that the backend knows these calls
+      // can't be tail calls.
+      if (auto *CI = dyn_cast<CallInst>(CB))
         CI->setTailCallKind(CallInst::TCK_NoTail);
+
+      // Remove the ARC intrinsic function operand from the operand bundle.
+      OperandBundleDef OB("clang.arc.attachedcall", None);
+      auto *NewCB = CallBase::Create(CB, OB, CB);
+      CB->replaceAllUsesWith(NewCB);
+      CB->eraseFromParent();
+    }
   } else {
     for (auto P : RVCalls)
       EraseInstruction(P.first);
   }
 
   RVCalls.clear();
 }

llvm/lib/Transforms/ObjCARC/ObjCARCContract.cpp

 bool ObjCARCContract::run(Function &F, AAResults *A, DominatorTree *D) {
   if (!EnableARCOpts)
     return false;
 
   Changed = CFGChanged = false;
   AA = A;
   DT = D;
   PA.setAA(A);
-  BundledRetainClaimRVs BRV(EP, true);
+  BundledRetainClaimRVs BRV(true);
   BundledInsts = &BRV;
 
   std::pair<bool, bool> R = BundledInsts->insertAfterInvokes(F, DT);
   Changed |= R.first;
   CFGChanged |= R.second;
 
   DenseMap<BasicBlock *, ColorVector> BlockColors;
   if (F.hasPersonalityFn() &&

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

void ObjCARCOpt::init(Module &M) {
   EP.init(&M);
 }
 
 bool ObjCARCOpt::run(Function &F, AAResults &AA) {
   if (!EnableARCOpts)
     return false;
 
   Changed = CFGChanged = false;
-  BundledRetainClaimRVs BRV(EP, false);
+  BundledRetainClaimRVs BRV(false);
   BundledInsts = &BRV;
 
   LLVM_DEBUG(dbgs() << "<<< ObjCARCOpt: Visiting Function: " << F.getName()
                     << " >>>"
                        "\n");
 
   std::pair<bool, bool> R = BundledInsts->insertAfterInvokes(F, nullptr);
   Changed |= R.first;

llvm/lib/Transforms/Utils/InlineFunction.cpp

 ///
 /// 2. If there is a call in the callee return block that doesn't have operand
 ///    bundle "clang.arc.attachedcall", the operand bundle on the original call
 ///    is transferred to the call in the callee.
 ///
 /// 3. Otherwise, a call to objc_retain is inserted if the call in the caller is
 ///    a retainRV call.
 static void
-inlineRetainOrClaimRVCalls(CallBase &CB,
+inlineRetainOrClaimRVCalls(CallBase &CB, objcarc::ARCInstKind RVCallKind,
                            const SmallVectorImpl<ReturnInst *> &Returns) {
   Module *Mod = CB.getModule();
-  bool IsRetainRV = objcarc::hasAttachedCallOpBundle(&CB, true),
+  assert(((RVCallKind == objcarc::ARCInstKind::RetainRV) ||
+          (RVCallKind == objcarc::ARCInstKind::ClaimRV)) &&
+         "unexpected ARC function");
+  bool IsRetainRV = RVCallKind == objcarc::ARCInstKind::RetainRV,
        IsClaimRV = !IsRetainRV;
 
   for (auto *RI : Returns) {
     Value *RetOpnd = objcarc::GetRCIdentityRoot(RI->getOperand(0));
     BasicBlock::reverse_iterator I = ++(RI->getIterator().getReverse());
     BasicBlock::reverse_iterator EI = RI->getParent()->rend();
     bool InsertRetainCall = IsRetainRV;
     IRBuilder<> Builder(RI->getContext());
for (; I != EI;) {
           II->eraseFromParent();
           InsertRetainCall = false;
         }
       } else if (auto *CI = dyn_cast<CallInst>(&*CurI)) {
         if (objcarc::GetRCIdentityRoot(CI) == RetOpnd &&
             !objcarc::hasAttachedCallOpBundle(CI)) {
           // If we've found an unannotated call that defines RetOpnd, add a
           // "clang.arc.attachedcall" operand bundle.
-          Value *BundleArgs[] = {ConstantInt::get(
-              Builder.getInt64Ty(),
-              objcarc::getAttachedCallOperandBundleEnum(IsRetainRV))};
+          Value *BundleArgs[] = {objcarc::getAttachedARCFunction(&CB).second};
           OperandBundleDef OB("clang.arc.attachedcall", BundleArgs);
           auto *NewCall = CallBase::addOperandBundle(
               CI, LLVMContext::OB_clang_arc_attachedcall, OB, CI);
           NewCall->copyMetadata(*CI);
           CI->replaceAllUsesWith(NewCall);
           CI->eraseFromParent();
           InsertRetainCall = false;
         }
Function::iterator FirstNewBlock;
     // happy with whatever the cloner can do.
     CloneAndPruneFunctionInto(Caller, CalledFunc, VMap,
                               /*ModuleLevelChanges=*/false, Returns, ".i",
                               &InlinedFunctionInfo, &CB);
     // Remember the first block that is newly cloned over.
     FirstNewBlock = LastBlock; ++FirstNewBlock;
 
     // Insert retainRV/clainRV runtime calls.
-    if (objcarc::hasAttachedCallOpBundle(&CB))
-      inlineRetainOrClaimRVCalls(CB, Returns);
+    objcarc::ARCInstKind RVCallKind = objcarc::getAttachedARCFunctionKind(&CB);
+    if (RVCallKind != objcarc::ARCInstKind::None)
+      inlineRetainOrClaimRVCalls(CB, RVCallKind, Returns);
 
     // Updated caller/callee profiles only when requested. For sample loader
     // inlining, the context-sensitive inlinee profile doesn't need to be
     // subtracted from callee profile, and the inlined clone also doesn't need
     // to be scaled based on call site count.
     if (IFI.UpdateProfile) {
       if (IFI.CallerBFI != nullptr && IFI.CalleeBFI != nullptr)
         // Update the BFI of blocks cloned into the caller.

llvm/test/CodeGen/AArch64/call-rv-marker.ll

 define dso_local i8* @rv_marker_1() {
 ; CHECK-LABEL:    rv_marker_1:
 ; CHECK:           .cfi_offset w30, -16
 ; CHECK-NEXT:      bl foo1
 ; SELDAG-NEXT:     mov x29, x29
 ; GISEL-NOT:       mov x29, x29
 ;
 entry:
-  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @foo1() [ "clang.arc.attachedcall"() ]
   ret i8* %call
 }
 
 define dso_local void @rv_marker_2_select(i32 %c) {
 ; CHECK-LABEL: rv_marker_2_select:
 ; SELDAG:        cinc  w0, w8, eq
 ; GISEL:         csinc w0, w8, wzr, eq
 ; CHECK-NEXT:    bl  foo0
 ; SELDAG-NEXT:   mov x29, x29
 ; CHECK-NEXT:    ldr x30, [sp], #16
 ; CHECK-NEXT:    b  foo2
 ;
 entry:
   %tobool.not = icmp eq i32 %c, 0
   %.sink = select i1 %tobool.not, i32 2, i32 1
-  %call1 = call i8* @foo0(i32 %.sink) [ "clang.arc.attachedcall"(i64 0) ]
+  %call1 = call i8* @foo0(i32 %.sink) [ "clang.arc.attachedcall"() ]
   tail call void @foo2(i8* %call1)
   ret void
 }
 
 define dso_local void @rv_marker_3() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: rv_marker_3
 ; CHECK:         .cfi_offset w30, -32
 ; CHECK-NEXT:    bl  foo1
 ; SELDAG-NEXT:   mov x29, x29
 ;
 entry:
-  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @foo1() [ "clang.arc.attachedcall"() ]
   invoke void @objc_object(i8* %call) #5
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   tail call void @llvm.objc.release(i8* %call)
   ret void
 
 lpad:                                             ; preds = %entry

 ; CHECK-NEXT:     bl  foo1
 ; SELDAG-NEXT:    mov x29, x29
 ; CHECK-NEXT: .Ltmp4:
 ;
 entry:
   %s = alloca %struct.S, align 1
   %0 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 0
   call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %0) #2
-  %call = invoke i8* @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = invoke i8* @foo1() [ "clang.arc.attachedcall"() ]
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   invoke void @objc_object(i8* %call) #5
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %invoke.cont
   tail call void @llvm.objc.release(i8* %call)

 ; CHECK-LABEL: rv_marker_5_indirect_call
 ; CHECK:         ldr [[ADDR:x[0-9]+]], [
 ; CHECK-NEXT:    blr [[ADDR]]
 ; SLEDAG-NEXT:   mov x29, x29
 ; GISEL-NOT:     mov x29, x29
 ;
 entry:
   %0 = load i8* ()*, i8* ()** @fptr, align 8
-  %call = call i8* %0() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* %0() [ "clang.arc.attachedcall"() ]
   tail call void @foo2(i8* %call)
   ret i8* %call
 }
 
 declare i8* @foo(i64, i64, i64)
 
 define dso_local void @rv_marker_multiarg(i64 %a, i64 %b, i64 %c) {
 ; CHECK-LABEL: rv_marker_multiarg
 ; CHECK:        mov [[TMP:x[0-9]+]], x0
 ; CHECK-NEXT:   mov x0, x2
 ; CHECK-NEXT:   mov x2, [[TMP]]
 ; CHECK-NEXT:   bl  foo
 ; SELDAG-NEXT:  mov x29, x29
 ; GISEL-NOT:    mov x29, x29
-  call i8* @foo(i64 %c, i64 %b, i64 %a) [ "clang.arc.attachedcall"(i64 0) ]
+  call i8* @foo(i64 %c, i64 %b, i64 %a) [ "clang.arc.attachedcall"() ]
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/test/CodeGen/X86/call-rv-marker.ll

 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 ; CHECK-NEXT:    callq   _foo1
 ; CHECK-NEXT:    movq    %rax, %rdi
 ; CHECK-NEXT:    callq   _objc_retainAutoreleasedReturnValue
 ; CHECK-NEXT:    popq    %rcx
 ; CHECK-NEXT:    retq
 ;
 entry:
-  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   ret i8* %call
 }
 
 define i8* @rv_marker_1_claim() {
 ; CHECK-LABEL:  rv_marker_1_claim:
 ; CHECK:         pushq %rax
 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 ; CHECK-NEXT:    callq   _foo1
 ; CHECK-NEXT:    movq    %rax, %rdi
 ; CHECK-NEXT:    callq   _objc_unsafeClaimAutoreleasedReturnValue
 ; CHECK-NEXT:    popq    %rcx
 ; CHECK-NEXT:    retq
 ;
 entry:
-  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i64 1) ]
+  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_unsafeClaimAutoreleasedReturnValue) ]
   ret i8* %call
 }
 
 define void @rv_marker_2_select(i32 %c) {
 ; CHECK-LABEL: rv_marker_2_select:
 ; CHECK:        pushq   %rax
 ; CHECK-NEXT:   .cfi_def_cfa_offset 16
 ; CHECK-NEXT:   cmpl    $1, %edi
 ; CHECK-NEXT:   movl    $1, %edi
 ; CHECK-NEXT:   adcl    $0, %edi
 ; CHECK-NEXT:   callq   _foo0
 ; CHECK-NEXT:   movq    %rax, %rdi
 ; CHECK-NEXT:   callq   _objc_retainAutoreleasedReturnValue
 ; CHECK-NEXT:   movq    %rax, %rdi
 ; CHECK-NEXT:   popq    %rax
 ; CHECK-NEXT:   jmp _foo2
 ;
 entry:
   %tobool.not = icmp eq i32 %c, 0
   %.sink = select i1 %tobool.not, i32 2, i32 1
-  %call1 = call i8* @foo0(i32 %.sink) [ "clang.arc.attachedcall"(i64 0) ]
+  %call1 = call i8* @foo0(i32 %.sink) [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   tail call void @foo2(i8* %call1)
   ret void
 }
 
 define void @rv_marker_3() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: rv_marker_3
 ; CHECK:         pushq   %r14
 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 ; CHECK-NEXT:    pushq   %rbx
 ; CHECK-NEXT:    .cfi_def_cfa_offset 24
 ; CHECK-NEXT:    pushq   %rax
 ; CHECK-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-NEXT:    .cfi_offset %rbx, -24
 ; CHECK-NEXT:    .cfi_offset %r14, -16
 ; CHECK-NEXT:    callq   _foo1
 ; CHECK-NEXT:    movq    %rax, %rdi
 ; CHECK-NEXT:    callq   _objc_retainAutoreleasedReturnValue
 ; CHECK-NEXT:    movq    %rax, %rbx
 ; CHECK-NEXT: Ltmp0:
 ;
 entry:
-  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   invoke void @objc_object(i8* %call) #5
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   tail call void @llvm.objc.release(i8* %call)
   ret void
 
 lpad:                                             ; preds = %entry

 ; CHECK-NEXT:    movq    %rax, %rdi
 ; CHECK-NEXT:    callq   _objc_retainAutoreleasedReturnValue
 ; CHECK-NEXT: Ltmp4:
 ;
 entry:
   %s = alloca %struct.S, align 1
   %0 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 0
   call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %0) #2
-  %call = invoke i8* @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = invoke i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   invoke void @objc_object(i8* %call) #5
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %invoke.cont
   tail call void @llvm.objc.release(i8* %call)

 ; CHECK-NEXT:    movq    %rax, %rdi
 ; CHECK-NEXT:    callq   _foo2
 ; CHECK-NEXT:    movq    %rbx, %rax
 ; CHECK-NEXT:    popq    %rbx
 ; CHECK-NEXT:    retq
 ;
 entry:
   %lv = load i8* ()*, i8* ()** @fptr, align 8
-  %call = call i8* %lv() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* %lv() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   tail call void @foo2(i8* %call)
   ret i8* %call
 }
 
 declare i8* @foo(i64, i64, i64)
 
 define void @rv_marker_multiarg(i64 %a, i64 %b, i64 %c) {
 ; CHECK-LABEL: rv_marker_multiarg
 ; CHECK:         pushq   %rax
 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 ; CHECK-NEXT:    movq    %rdi, %rax
 ; CHECK-NEXT:    movq    %rdx, %rdi
 ; CHECK-NEXT:    movq    %rax, %rdx
 ; CHECK-NEXT:    callq   _foo
 ; CHECK-NEXT:    movq    %rax, %rdi
 ; CHECK-NEXT:    callq   _objc_retainAutoreleasedReturnValue
 ; CHECK-NEXT:    popq    %rax
 ; CHECK-NEXT:    retq
 ;
-  %r = call i8* @foo(i64 %c, i64 %b, i64 %a) [ "clang.arc.attachedcall"(i64 0) ]
+  %r = call i8* @foo(i64 %c, i64 %b, i64 %a) [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   ret void
 }
 
 define void @test_nonlazybind() {
 ; CHECK-LABEL: _test_nonlazybind:
 ; CHECK:      bb.0:
 ; CHECK-NEXT:  pushq   %rax
 ; CHECK-NEXT:  .cfi_def_cfa_offset 16
 ; CHECK-NEXT:  callq   *_foo_nonlazybind@GOTPCREL(%rip)
 ; CHECK-NEXT:  movq    %rax, %rdi
 ; CHECK-NEXT:  callq   _objc_retainAutoreleasedReturnValue
 ;
-  %call1 = notail call i8* @foo_nonlazybind() [ "clang.arc.attachedcall"(i64 0) ]
+  %call1 = notail call i8* @foo_nonlazybind() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   ret void
 }
 
 declare i8* @foo_nonlazybind()  nonlazybind
 
+declare i8* @objc_retainAutoreleasedReturnValue(i8*)
+declare i8* @objc_unsafeClaimAutoreleasedReturnValue(i8*)
 declare i32 @__gxx_personality_v0(...)

llvm/test/Transforms/DeadArgElim/deadretval.ll

 
 define internal i8* @callee4(i8* %a0) {
   ret i8* @g0;
 }
 
 declare void @llvm.objc.clang.arc.noop.use(...)
 
 ; CHECK-LABEL: define i8* @test4(
-; CHECK: tail call i8* @callee4() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: tail call i8* @callee4() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 
 define i8* @test4() {
-  %call = tail call i8* @callee4(i8* @g0) [ "clang.arc.attachedcall"(i64 0) ]
+  %call = tail call i8* @callee4(i8* @g0) [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   call void (...) @llvm.objc.clang.arc.noop.use(i8* %call)
   ret i8* @g0
 }
+
+declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)

llvm/test/Transforms/Inline/inline-retainRV-call.ll

 ; RUN: opt < %s -inline -S | FileCheck %s
 
 @g0 = global i8* null, align 8
 declare i8* @foo0()
 
 define i8* @callee0_autoreleaseRV() {
-  %call = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   %1 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %call)
   ret i8* %call
 }
 
 ; CHECK-LABEL: define void @test0_autoreleaseRV(
-; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 
 define void @test0_autoreleaseRV() {
-  %call = call i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret void
 }
 
 ; CHECK-LABEL: define void @test0_claimRV_autoreleaseRV(
-; CHECK: %[[CALL:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[CALL:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK: call void @llvm.objc.release(i8* %[[CALL]])
 ; CHECK-NEXT: ret void
 
 define void @test0_claimRV_autoreleaseRV() {
-  %call = call i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 1) ]
+  %call = call i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
   ret void
 }
 
 ; CHECK-LABEL: define void @test1_autoreleaseRV(
-; CHECK: invoke i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: invoke i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 
 define void @test1_autoreleaseRV() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
-  %call = invoke i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = invoke i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret void
 
 lpad:
   %0 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 }
 
 ; CHECK-LABEL: define void @test1_claimRV_autoreleaseRV(
-; CHECK: %[[INVOKE:.*]] = invoke i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[INVOKE:.*]] = invoke i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK: call void @llvm.objc.release(i8* %[[INVOKE]])
 ; CHECK-NEXT: br
 
 define void @test1_claimRV_autoreleaseRV() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
-  %call = invoke i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 1) ]
+  %call = invoke i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret void
 
 lpad:
   %0 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 }
 
 define i8* @callee1_no_autoreleaseRV() {
   %call = call i8* @foo0()
   ret i8* %call
 }
 
 ; CHECK-LABEL: define void @test2_no_autoreleaseRV(
-; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK-NEXT: ret void
 
 define void @test2_no_autoreleaseRV() {
-  %call = call i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret void
 }
 
 ; CHECK-LABEL: define void @test2_claimRV_no_autoreleaseRV(
-; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i64 1) ]
+; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
 ; CHECK-NEXT: ret void
 
 define void @test2_claimRV_no_autoreleaseRV() {
-  %call = call i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i64 1) ]
+  %call = call i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
   ret void
 }
 
 ; CHECK-LABEL: define void @test3_no_autoreleaseRV(
-; CHECK: invoke i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: invoke i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 
 define void @test3_no_autoreleaseRV() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
-  %call = invoke i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = invoke i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret void
 
 lpad:
   %0 = landingpad { i8*, i32 }
           cleanup

 ; autoreleaseRV call or a call.
 
 ; CHECK-LABEL: define void @test4_nocall(
 ; CHECK: %[[V0:.*]] = load i8*, i8** @g0,
 ; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %[[V0]])
 ; CHECK-NEXT: ret void
 
 define void @test4_nocall() {
-  %call = call i8* @callee2_nocall() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @callee2_nocall() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret void
 }
 
 ; CHECK-LABEL: define void @test4_claimRV_nocall(
 ; CHECK: %[[V0:.*]] = load i8*, i8** @g0,
 ; CHECK-NEXT: ret void
 
 define void @test4_claimRV_nocall() {
-  %call = call i8* @callee2_nocall() [ "clang.arc.attachedcall"(i64 1) ]
+  %call = call i8* @callee2_nocall() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
   ret void
 }
 
 ; Check that a call to @llvm.objc.retain is inserted if call to @foo already has
 ; the attribute. I'm not sure this will happen in practice.
 
 define i8* @callee3_marker() {
-  %1 = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+  %1 = call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret i8* %1
 }
 
 ; CHECK-LABEL: define void @test5(
-; CHECK: %[[V0:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[V0:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %[[V0]])
 ; CHECK-NEXT: ret void
 
 define void @test5() {
-  %call = call i8* @callee3_marker() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @callee3_marker() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret void
 }
 
 ; Don't pair up an autoreleaseRV in the callee and an retainRV in the caller
 ; if there is an instruction between the ret instruction and the call to
 ; autoreleaseRV that isn't a cast instruction.
 
 define i8* @callee0_autoreleaseRV2() {
-  %call = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   %1 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %call)
   store i8* null, i8** @g0
   ret i8* %call
 }
 
 ; CHECK-LABEL: define void @test6(
-; CHECK: %[[V0:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[V0:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK: call i8* @llvm.objc.autoreleaseReturnValue(i8* %[[V0]])
 ; CHECK: store i8* null, i8** @g0, align 8
 ; CHECK: call i8* @llvm.objc.retain(i8* %[[V0]])
 ; CHECK-NEXT: ret void
 
 define void @test6() {
-  %call = call i8* @callee0_autoreleaseRV2() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @callee0_autoreleaseRV2() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret void
 }
 
+declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
+declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
 declare i32 @__gxx_personality_v0(...)

llvm/test/Transforms/ObjCARC/contract-marker-funclet.ll

 
 invoke.cont:                                      ; preds = %entry
   %4 = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %call)
   call void @llvm.objc.release(i8* %4)
   ret void
 }
 
 ; CHECK-LABEL: define dso_local void @"?test_attr_claimRV@@YAXXZ"()
-; CHECK: %[[CALL4:.*]] = notail call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() [ "clang.arc.attachedcall"(i64 1) ]
+; CHECK: %[[CALL4:.*]] = notail call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() [ "clang.arc.attachedcall"() ]
 ; CHECK: call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %[[CALL4]])
 
 ; CHECK: %[[V1:.*]] = cleanuppad
-; CHECK: %[[CALL:.*]] = notail call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() [ "funclet"(token %[[V1]]), "clang.arc.attachedcall"(i64 1) ]
+; CHECK: %[[CALL:.*]] = notail call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() [ "funclet"(token %[[V1]]), "clang.arc.attachedcall"() ]
 ; CHECK: call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %[[CALL]]) [ "funclet"(token %[[V1]]) ]
 
 define dso_local void @"?test_attr_claimRV@@YAXXZ"() local_unnamed_addr #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @"?foo@@YAXXZ"()
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
-  %call.i4 = tail call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() #2 [ "clang.arc.attachedcall"(i64 1) ]
+  %call.i4 = tail call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() #2 [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
   ret void
 
 ehcleanup:                                        ; preds = %entry
   %0 = cleanuppad within none []
-  %call.i = call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() #2 [ "funclet"(token %0), "clang.arc.attachedcall"(i64 1) ]
+  %call.i = call i8* @"?noexcept_func@@YAPAUobjc_object@@XZ"() #2 [ "funclet"(token %0), "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
   cleanupret from %0 unwind to caller
 }
 
 declare i8* @"\01?f@@YAPAUobjc_object@@XZ"()
 
 declare i32 @__CxxFrameHandler3(...)
 
 declare void @"?foo@@YAXXZ"()

llvm/test/Transforms/ObjCARC/contract-rv-attr.ll

 ; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
 ; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 ; CHECK-LABEL: define void @test0() {
-; CHECK: %[[CALL:.*]] = notail call i8* @foo() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[CALL:.*]] = notail call i8* @foo() [ "clang.arc.attachedcall"() ]
 ; CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL]])
 
 define void @test0() {
-  %call1 = call i8* @foo() [ "clang.arc.attachedcall"(i64 0) ]
+  %call1 = call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret void
 }
 
 ; CHECK-LABEL: define void @test1() {
-; CHECK: %[[CALL:.*]] = notail call i8* @foo() [ "clang.arc.attachedcall"(i64 1) ]
+; CHECK: %[[CALL:.*]] = notail call i8* @foo() [ "clang.arc.attachedcall"() ]
 ; CHECK: call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %[[CALL]])
 
 define void @test1() {
-  %call1 = call i8* @foo() [ "clang.arc.attachedcall"(i64 1) ]
+  %call1 = call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
   ret void
 }
 
 ; CHECK-LABEL:define i8* @test2(
-; CHECK: %[[CALL1:.*]] = invoke i8* @foo() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[CALL1:.*]] = invoke i8* @foo() [ "clang.arc.attachedcall"() ]
 
 ; CHECK: %[[V0:.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL1]])
 ; CHECK-NEXT: br
 
-; CHECK: %[[CALL3:.*]] = invoke i8* @foo() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[CALL3:.*]] = invoke i8* @foo() [ "clang.arc.attachedcall"() ]
 
 ; CHECK: %[[V2:.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL3]])
 ; CHECK-NEXT: br
 
 ; CHECK: %[[RETVAL:.*]] = phi i8* [ %[[V0]], {{.*}} ], [ %[[V2]], {{.*}} ]
 ; CHECK: ret i8* %[[RETVAL]]
 
 define i8* @test2(i1 zeroext %b) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br i1 %b, label %if.then, label %if.end
 
 if.then:
-  %call1 = invoke i8* @foo() [ "clang.arc.attachedcall"(i64 0) ]
+  %call1 = invoke i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
           to label %cleanup unwind label %lpad
 
 lpad:
   %0 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 
 if.end:
-  %call3 = invoke i8* @foo() [ "clang.arc.attachedcall"(i64 0) ]
+  %call3 = invoke i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
           to label %cleanup unwind label %lpad
 
 cleanup:
   %retval.0 = phi i8* [ %call1, %if.then ], [ %call3, %if.end ]
   ret i8* %retval.0
 }
 
 declare i8* @foo()
 declare i32 @__gxx_personality_v0(...)
+declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
+declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
 
 !llvm.module.flags = !{!0}
 
 !0 = !{i32 1, !"clang.arc.retainAutoreleasedReturnValueMarker", !"mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue"}

llvm/test/Transforms/ObjCARC/rv.ll

 ; Remove operand bundle "clang.arc.attachedcall" and the autoreleaseRV call if the call
 ; is a tail call.
 
 ; CHECK-LABEL: define i8* @test31(
 ; CHECK-NEXT: %[[CALL:.*]] = tail call i8* @returner()
 ; CHECK-NEXT: ret i8* %[[CALL]]
 
 define i8* @test31() {
-  %call = tail call i8* @returner() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = tail call i8* @returner() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   call void (...) @llvm.objc.clang.arc.noop.use(i8* %call)
   %1 = call i8* @llvm.objc.autoreleaseReturnValue(i8* %call)
   ret i8* %1
 }
 
 ; CHECK-LABEL: define i8* @test32(
-; CHECK: %[[CALL:.*]] = call i8* @returner() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK: %[[CALL:.*]] = call i8* @returner() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK: call void (...) @llvm.objc.clang.arc.noop.use(i8* %[[CALL]])
 ; CHECK: call i8* @llvm.objc.autoreleaseReturnValue(i8* %[[CALL]])
 
 define i8* @test32() {
-  %call = call i8* @returner() [ "clang.arc.attachedcall"(i64 0) ]
+  %call = call i8* @returner() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   call void (...) @llvm.objc.clang.arc.noop.use(i8* %call)
   %1 = call i8* @llvm.objc.autoreleaseReturnValue(i8* %call)
   ret i8* %1
 }
 
 !0 = !{}
 
 ; CHECK: attributes [[NUW]] = { nounwind }

llvm/test/Transforms/SCCP/clang-arc-rv.ll

define internal i8* @foo() {
   ret i8* @g0
 }
 
 ; CHECK-LABEL: @test(
 ; CHECK: %[[R:.*]] = call i8* @foo()
 ; CHECK call void (...) @llvm.objc.clang.arc.noop.use(i8* %[[R]])
 
 define void @test() {
-  %r = call i8* @foo() [ "clang.arc.attachedcall"(i64 1) ]
+  %r = call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
   call void (...) @llvm.objc.clang.arc.noop.use(i8* %r)
   ret void
 }
 
+declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
 declare void @llvm.objc.clang.arc.noop.use(...)

llvm/test/Transforms/TailCallElim/deopt-bundle.ll

 }
 
 ; CHECK-LABEL: @test_clang_arc_attachedcall(
 ; CHECK: tail call i8* @getObj(
 
 declare i8* @getObj()
 
 define i8* @test_clang_arc_attachedcall() {
-  %r = call i8* @getObj() [ "clang.arc.attachedcall"(i64 0) ]
+  %r = call i8* @getObj() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret i8* %r
 }
+
+declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)

llvm/test/Verifier/operand-bundles.ll

entry:
   call void @g() [ "gc-transition"(i32 42, i64 100, i32 %x), "gc-transition"(float 0.0, i64 100, i32 %l) ]
   call void @g() [ "gc-transition"(i32 42, i64 120) ]  ;; The verifier should not complain about this one
   %x = add i32 42, 1
   ret void
 }
 
 define void @f_clang_arc_attachedcall() {
 ; CHECK: Multiple "clang.arc.attachedcall" operand bundles
-; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(i64 0), "clang.arc.attachedcall"(i64 0) ]
+; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue), "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK-NEXT: must call a function returning a pointer
-; CHECK-NEXT: call i8 @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK-NEXT: call i8 @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 
-  call %0* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
-  call %0* @foo0() [ "clang.arc.attachedcall"(i64 0), "clang.arc.attachedcall"(i64 0) ]
-  call i8 @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
+  call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue), "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
+  call i8 @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   ret void
 }
+
+declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)