[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

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.

[ahatanak]

https://reviews.llvm.org/D103000 is the llvm patch.

[rjmccall]

LGTM

clang/lib/CodeGen/CGObjC.cpp

static void setARCRuntimeFunctionLinkage(CodeGenModule &CGM, llvm::Value *RTF) {
   }
 }
 
 static void setARCRuntimeFunctionLinkage(CodeGenModule &CGM,
                                          llvm::FunctionCallee RTF) {
   setARCRuntimeFunctionLinkage(CGM, RTF.getCallee());
 }
 
+static llvm::Function *getARCIntrinsic(llvm::Intrinsic::ID IntID,
+                                       CodeGenModule &CGM) {
+  llvm::Function *fn = CGM.getIntrinsic(IntID);
+  setARCRuntimeFunctionLinkage(CGM, fn);
+  return fn;
+}
+
 /// Perform an operation having the signature
 ///   i8* (i8*)
 /// where a null input causes a no-op and returns null.
 static llvm::Value *emitARCValueOperation(
     CodeGenFunction &CGF, llvm::Value *value, llvm::Type *returnType,
     llvm::Function *&fn, llvm::Intrinsic::ID IntID,
     llvm::CallInst::TailCallKind tailKind = llvm::CallInst::TCK_None) {
   if (isa<llvm::ConstantPointerNull>(value))
     return value;
 
-  if (!fn) {
-    fn = CGF.CGM.getIntrinsic(IntID);
-    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(IntID, CGF.CGM);
 
   // Cast the argument to 'id'.
   llvm::Type *origType = returnType ? returnType : value->getType();
   value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy);
 
   // Call the function.
   llvm::CallInst *call = CGF.EmitNounwindRuntimeCall(fn, value);
   call->setTailCallKind(tailKind);
 
   // Cast the result back to the original type.
   return CGF.Builder.CreateBitCast(call, origType);
 }
 
 /// Perform an operation having the following signature:
 ///   i8* (i8**)
 static llvm::Value *emitARCLoadOperation(CodeGenFunction &CGF, Address addr,
                                          llvm::Function *&fn,
                                          llvm::Intrinsic::ID IntID) {
-  if (!fn) {
-    fn = CGF.CGM.getIntrinsic(IntID);
-    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(IntID, CGF.CGM);
 
   // Cast the argument to 'id*'.
   llvm::Type *origType = addr.getElementType();
   addr = CGF.Builder.CreateBitCast(addr, CGF.Int8PtrPtrTy);
 
   // Call the function.
   llvm::Value *result = CGF.EmitNounwindRuntimeCall(fn, addr.getPointer());
 
   // Cast the result back to a dereference of the original type.
   if (origType != CGF.Int8PtrTy)
     result = CGF.Builder.CreateBitCast(result, origType);
 
   return result;
 }
 
 /// Perform an operation having the following signature:
 ///   i8* (i8**, i8*)
 static llvm::Value *emitARCStoreOperation(CodeGenFunction &CGF, Address addr,
                                           llvm::Value *value,
                                           llvm::Function *&fn,
                                           llvm::Intrinsic::ID IntID,
                                           bool ignored) {
   assert(addr.getElementType() == value->getType());
 
-  if (!fn) {
-    fn = CGF.CGM.getIntrinsic(IntID);
-    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(IntID, CGF.CGM);
 
   llvm::Type *origType = value->getType();
 
   llvm::Value *args[] = {
     CGF.Builder.CreateBitCast(addr.getPointer(), CGF.Int8PtrPtrTy),
     CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy)
   };
   llvm::CallInst *result = CGF.EmitNounwindRuntimeCall(fn, args);
 
   if (ignored) return nullptr;
 
   return CGF.Builder.CreateBitCast(result, origType);
 }
 
 /// Perform an operation having the following signature:
 ///   void (i8**, i8**)
 static void emitARCCopyOperation(CodeGenFunction &CGF, Address dst, Address src,
                                  llvm::Function *&fn,
                                  llvm::Intrinsic::ID IntID) {
   assert(dst.getType() == src.getType());
 
-  if (!fn) {
-    fn = CGF.CGM.getIntrinsic(IntID);
-    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(IntID, CGF.CGM);
 
   llvm::Value *args[] = {
     CGF.Builder.CreateBitCast(dst.getPointer(), CGF.Int8PtrPtrTy),
     CGF.Builder.CreateBitCast(src.getPointer(), CGF.Int8PtrPtrTy)
   };
   CGF.EmitNounwindRuntimeCall(fn, args);
 }
 
static llvm::Value *emitOptimizedARCReturnCall(llvm::Value *value,
                                                bool IsRetainRV,
                                                CodeGenFunction &CGF) {
   emitAutoreleasedReturnValueMarker(CGF);
 
   // Add operand bundle "clang.arc.attachedcall" to the call instead of emitting
   // retainRV or claimRV calls in the IR. We currently do this only when the
   // optimization level isn't -O0 since global-isel, which is currently run at
   // -O0, doesn't know about the operand bundle.
+  ObjCEntrypoints &EPs = CGF.CGM.getObjCEntrypoints();
+  llvm::Function *&EP = IsRetainRV
+                            ? EPs.objc_retainAutoreleasedReturnValue
+                            : EPs.objc_unsafeClaimAutoreleasedReturnValue;
+  llvm::Intrinsic::ID IID =
+      IsRetainRV ? llvm::Intrinsic::objc_retainAutoreleasedReturnValue
+                 : llvm::Intrinsic::objc_unsafeClaimAutoreleasedReturnValue;
+  EP = getARCIntrinsic(IID, CGF.CGM);
 
   // FIXME: Do this when the target isn't aarch64.
   if (CGF.CGM.getCodeGenOpts().OptimizationLevel > 0 &&
       CGF.CGM.getTarget().getTriple().isAArch64()) {
-    llvm::Value *bundleArgs[] = {llvm::ConstantInt::get(
-        CGF.Int64Ty,
-        llvm::objcarc::getAttachedCallOperandBundleEnum(IsRetainRV))};
+    llvm::Value *bundleArgs[] = {EP};
     llvm::OperandBundleDef OB("clang.arc.attachedcall", bundleArgs);
     auto *oldCall = cast<llvm::CallBase>(value);
     llvm::CallBase *newCall = llvm::CallBase::addOperandBundle(
         oldCall, llvm::LLVMContext::OB_clang_arc_attachedcall, OB, oldCall);
     newCall->copyMetadata(*oldCall);
     oldCall->replaceAllUsesWith(newCall);
     oldCall->eraseFromParent();
     CGF.EmitARCNoopIntrinsicUse(newCall);
     return newCall;
   }
 
   bool isNoTail =
       CGF.CGM.getTargetCodeGenInfo().markARCOptimizedReturnCallsAsNoTail();
   llvm::CallInst::TailCallKind tailKind =
       isNoTail ? llvm::CallInst::TCK_NoTail : llvm::CallInst::TCK_None;
-  ObjCEntrypoints &EPs = CGF.CGM.getObjCEntrypoints();
-  llvm::Function *&EP = IsRetainRV
-                            ? EPs.objc_retainAutoreleasedReturnValue
-                            : EPs.objc_unsafeClaimAutoreleasedReturnValue;
-  llvm::Intrinsic::ID IID =
-      IsRetainRV ? llvm::Intrinsic::objc_retainAutoreleasedReturnValue
-                 : llvm::Intrinsic::objc_unsafeClaimAutoreleasedReturnValue;
   return emitARCValueOperation(CGF, value, nullptr, EP, IID, tailKind);
 }
 
 /// Retain the given object which is the result of a function call.
 ///   call i8* \@objc_retainAutoreleasedReturnValue(i8* %value)
 ///
 /// Yes, this function name is one character away from a different
 /// call with completely different semantics.

 
 /// Release the given object.
 ///   call void \@objc_release(i8* %value)
 void CodeGenFunction::EmitARCRelease(llvm::Value *value,
                                      ARCPreciseLifetime_t precise) {
   if (isa<llvm::ConstantPointerNull>(value)) return;
 
   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_release;
-  if (!fn) {
-    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_release);
-    setARCRuntimeFunctionLinkage(CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(llvm::Intrinsic::objc_release, CGM);
 
   // Cast the argument to 'id'.
   value = Builder.CreateBitCast(value, Int8PtrTy);
 
   // Call objc_release.
   llvm::CallInst *call = EmitNounwindRuntimeCall(fn, value);
 
   if (precise == ARCImpreciseLifetime) {

 /// Store into a strong object.  Always calls this:
 ///   call void \@objc_storeStrong(i8** %addr, i8* %value)
 llvm::Value *CodeGenFunction::EmitARCStoreStrongCall(Address addr,
                                                      llvm::Value *value,
                                                      bool ignored) {
   assert(addr.getElementType() == value->getType());
 
   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_storeStrong;
-  if (!fn) {
-    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_storeStrong);
-    setARCRuntimeFunctionLinkage(CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(llvm::Intrinsic::objc_storeStrong, CGM);
 
   llvm::Value *args[] = {
     Builder.CreateBitCast(addr.getPointer(), Int8PtrPtrTy),
     Builder.CreateBitCast(value, Int8PtrTy)
   };
   EmitNounwindRuntimeCall(fn, args);
 
   if (ignored) return nullptr;
emitARCStoreOperation(*this, addr, value,
                         CGM.getObjCEntrypoints().objc_initWeak,
                         llvm::Intrinsic::objc_initWeak, /*ignored*/ true);
 }
 
 /// void \@objc_destroyWeak(i8** %addr)
 /// Essentially objc_storeWeak(addr, nil).
 void CodeGenFunction::EmitARCDestroyWeak(Address addr) {
   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_destroyWeak;
-  if (!fn) {
-    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_destroyWeak);
-    setARCRuntimeFunctionLinkage(CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(llvm::Intrinsic::objc_destroyWeak, CGM);
 
   // Cast the argument to 'id*'.
   addr = Builder.CreateBitCast(addr, Int8PtrPtrTy);
 
   EmitNounwindRuntimeCall(fn, addr.getPointer());
 }
 
 /// void \@objc_moveWeak(i8** %dest, i8** %src)
void CodeGenFunction::emitARCMoveAssignWeak(QualType Ty, Address DstAddr,
   EmitARCStoreWeak(DstAddr, Object, false);
   EmitARCDestroyWeak(SrcAddr);
 }
 
 /// Produce the code to do a objc_autoreleasepool_push.
 ///   call i8* \@objc_autoreleasePoolPush(void)
 llvm::Value *CodeGenFunction::EmitObjCAutoreleasePoolPush() {
   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPush;
-  if (!fn) {
-    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_autoreleasePoolPush);
-    setARCRuntimeFunctionLinkage(CGM, fn);
-  }
+  if (!fn)
+    fn = getARCIntrinsic(llvm::Intrinsic::objc_autoreleasePoolPush, CGM);
 
   return EmitNounwindRuntimeCall(fn);
 }
 
 /// Produce the code to do a primitive release.
 ///   call void \@objc_autoreleasePoolPop(i8* %ptr)
 void CodeGenFunction::EmitObjCAutoreleasePoolPop(llvm::Value *value) {
   assert(value->getType() == Int8PtrTy);
 
   if (getInvokeDest()) {
     // Call the runtime method not the intrinsic if we are handling exceptions
     llvm::FunctionCallee &fn =
         CGM.getObjCEntrypoints().objc_autoreleasePoolPopInvoke;
     if (!fn) {
       llvm::FunctionType *fnType =
         llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
       fn = CGM.CreateRuntimeFunction(fnType, "objc_autoreleasePoolPop");
       setARCRuntimeFunctionLinkage(CGM, fn);
     }
 
     // objc_autoreleasePoolPop can throw.
     EmitRuntimeCallOrInvoke(fn, value);
   } else {
     llvm::FunctionCallee &fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPop;
-    if (!fn) {
-      fn = CGM.getIntrinsic(llvm::Intrinsic::objc_autoreleasePoolPop);
-      setARCRuntimeFunctionLinkage(CGM, fn);
-    }
+    if (!fn)
+      fn = getARCIntrinsic(llvm::Intrinsic::objc_autoreleasePoolPop, CGM);
 
     EmitRuntimeCall(fn, value);
   }
 }
 
 /// Produce the code to do an MRR version objc_autoreleasepool_push.
 /// Which is: [[NSAutoreleasePool alloc] init];
 /// Where alloc is declared as: + (id) alloc; in NSAutoreleasePool class.

clang/test/CodeGenObjC/arc-rv-attr.m

 // RUN: %clang_cc1 -triple arm64-apple-ios9 -fobjc-runtime=ios-9.0 -fobjc-arc -O -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK
 
 @class A;
 
 A *makeA(void);
 
 void test_assign() {
   __unsafe_unretained id x;
   x = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_assign()
 // CHECK:         [[X:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A:.*]]* @makeA() [ "clang.arc.attachedcall"(i64 1) ]
+// CHECK:         [[T0:%.*]] = call [[A:.*]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_assign_assign() {
   __unsafe_unretained id x, y;
   x = y = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_assign_assign()
 // CHECK:         [[X:%.*]] = alloca i8*
 // CHECK:         [[Y:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 1) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_strong_assign_assign() {
   __strong id x;
   __unsafe_unretained id y;
   x = y = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_strong_assign_assign()
 // CHECK:         [[X:%.*]] = alloca i8*
 // CHECK:         [[Y:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 0) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT:    [[OLD:%.*]] = load i8*, i8** [[X]]
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    call void @llvm.objc.release(i8* [[OLD]]
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    [[T0:%.*]] = load i8*, i8** [[X]]
 // CHECK-NEXT:    call void @llvm.objc.release(i8* [[T0]])
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_assign_strong_assign() {
   __unsafe_unretained id x;
   __strong id y;
   x = y = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_assign_strong_assign()
 // CHECK:         [[X:%.*]] = alloca i8*
 // CHECK:         [[Y:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 0) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    [[OLD:%.*]] = load i8*, i8** [[Y]]
 // CHECK-NEXT:    store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT:    call void @llvm.objc.release(i8* [[OLD]]
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    [[T0:%.*]] = load i8*, i8** [[Y]]
 // CHECK-NEXT:    call void @llvm.objc.release(i8* [[T0]])
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_init() {
   __unsafe_unretained id x = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_init()
 // CHECK:         [[X:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 1) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_init_assignment() {
   __unsafe_unretained id x;
   __unsafe_unretained id y = x = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_init_assignment()
 // CHECK:         [[X:%.*]] = alloca i8*
 // CHECK:         [[Y:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 1) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_strong_init_assignment() {
   __unsafe_unretained id x;
   __strong id y = x = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_strong_init_assignment()
 // CHECK:         [[X:%.*]] = alloca i8*
 // CHECK:         [[Y:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 0) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT:    [[T0:%.*]] = load i8*, i8** [[Y]]
 // CHECK-NEXT:    call void @llvm.objc.release(i8* [[T0]])
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_init_strong_assignment() {
   __strong id x;
   __unsafe_unretained id y = x = makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_init_strong_assignment()
 // CHECK:         [[X:%.*]] = alloca i8*
 // CHECK:         [[Y:%.*]] = alloca i8*
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 0) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
 // CHECK-NEXT:    [[OLD:%.*]] = load i8*, i8** [[X]]
 // CHECK-NEXT:    store i8* [[T1]], i8** [[X]]
 // CHECK-NEXT:    call void @llvm.objc.release(i8* [[OLD]])
 // CHECK-NEXT:    store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    [[T0:%.*]] = load i8*, i8** [[X]]
 // CHECK-NEXT:    call void @llvm.objc.release(i8* [[T0]])
 // CHECK-NEXT:    bitcast
 // CHECK-NEXT:    lifetime.end
 // CHECK-NEXT:    ret void
 
 void test_ignored() {
   makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_ignored()
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 1) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    ret void
 
 void test_cast_to_void() {
   (void) makeA();
 }
 // CHECK-LABEL: define{{.*}} void @test_cast_to_void()
-// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i64 1) ]
+// CHECK:         [[T0:%.*]] = call [[A]]* @makeA() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
 // CHECK-NEXT:    call void (...) @llvm.objc.clang.arc.noop.use({{.*}} [[T0]])
 // CHECK-NEXT:    ret void
 
 // This is always at the end of the module.
 
 // CHECK-OPTIMIZED: !llvm.module.flags = !{!0,
 // CHECK-OPTIMIZED: !0 = !{i32 1, !"clang.arc.retainAutoreleasedReturnValueMarker", !"mov{{.*}}marker for objc_retainAutoreleaseReturnValue"}

clang/test/CodeGenObjCXX/arc-rv-attr.mm

 // RUN: %clang_cc1 -triple arm64-apple-ios9 -fobjc-runtime=ios-9.0 -fobjc-arc -std=c++11 -O -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK
 
 id foo(void);
 
 // CHECK-LABEL: define{{.*}} void @_Z14test_list_initv(
-// CHECK: %[[CALL1:.*]] = call i8* @_Z3foov() [ "clang.arc.attachedcall"(i64 0) ]
+// CHECK: %[[CALL1:.*]] = call i8* @_Z3foov() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 // CHECK: call i8* @llvm.objc.retain(i8* %[[CALL1]])
 
 void test_list_init() {
   auto t = id{foo()};
 }