Change CGObjC to use objc intrinsics instead of runtime methods

[pete]

Summary

This is the final commit to make clang emit the intrinsics so that the ARC optimizer will always see intrinsics instead of runtime method calls.

The changes are mostly mechanical, just using getIntrinsic instead of creating a new method.

The tricky cases are:

• Old runtimes get weak_external declarations, so i've set the linkage on the intrinsics
• retain/release should be nonlazybind, which will now be handed in llvm itself when converted from intrinsic to runtime method for ISel
• objc_autoreleasePoolPop can throw so needs to invoke the runtime method, or call the intrinsic, as needed

[rjmccall]

You're making intrinsics with weak_external linkage? I feel like that's going to be unnecessarily awkward in the future, but okay.

[pete]

In D55802#1334008, @rjmccall wrote:

You're making intrinsics with weak_external linkage? I feel like that's going to be unnecessarily awkward in the future, but okay.

Yeah... i was a little surprised that was possible, but seems to work just fine.

Thanks for the quick review! Will land it first thing tomorrow.

[theraven]

After some bisection, it appears that this is the revision that introduced the regression in the GNUstep Objective-C runtime test suite that I reported on the list a few weeks ago. In this is the test (compiled with -fobjc-runtime=gnustep-2.0 -O3 and an ELF triple):

https://github.com/gnustep/libobjc2/blob/master/Test/AssociatedObject.m

After this change, Early CSE w/ MemorySSA is determining that the second load of deallocCalled is redundant. The code goes from:

  %7 = load i1, i1* @deallocCalled, align 1
  br i1 %7, label %8, label %9

; <label>:8:                                      ; preds = %0
  call void @__assert(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @__func__.main, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0)) #5
  unreachable

; <label>:9:                                      ; preds = %0
  call void @llvm.objc.autoreleasePoolPop(i8* %1)
  %10 = load i1, i1* @deallocCalled, align 1
  br i1 %10, label %12, label %11

; <label>:11:                                     ; preds = %9
  call void @__assert(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @__func__.main, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 29, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0)) #5
  unreachable

to:

  %7 = load i1, i1* @deallocCalled, align 1
  br i1 %7, label %8, label %9

; <label>:8:                                      ; preds = %0
  call void @__assert(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @__func__.main, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0)) #5
  unreachable

; <label>:9:                                      ; preds = %0
  call void @llvm.objc.autoreleasePoolPop(i8* %1)
  br i1 %7, label %11, label %10

; <label>:10:                                     ; preds = %9
  call void @__assert(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @__func__.main, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 29, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0)) #5
  unreachable

Later optimisations then determine that, because the assert does not return, the only possible value for %7 is false and cause the second assert to fire unconditionally.

It appears that we are not correctly modelling the side effects of the llvm.objc.autoreleasePoolPop intrinsic, but it's not entirely clear why not. The same test compiled for the macos runtime does not appear to exhibit the same behaviour. The previous revision, where we emitted a call to objc_autoreleasePoolPop and not the intrinsic worked correctly, but with this change the optimisers are assuming that no globals can be modified across an autorelease pool pop operation (at least, in some situations).

Looking at the definition of the intrinsic, I don't see anything wrong, so I still suspect that there is a MemorySSA bug that this has uncovered, rather than anything wrong in this series of commits. Any suggestions as to where to look would be appreciated.

lib/CodeGen/CGObjC.cpp

if (!fn) {
     fn = CGM.CreateRuntimeFunction(fnType, "clang.arc.use");
   }
 
   // This isn't really a "runtime" function, but as an intrinsic it
   // doesn't really matter as long as we align things up.
   EmitNounwindRuntimeCall(fn, values);
 }
 
-
-static llvm::Constant *createARCRuntimeFunction(CodeGenModule &CGM,
-                                                llvm::FunctionType *FTy,
-                                                StringRef Name) {
-  llvm::Constant *RTF = CGM.CreateRuntimeFunction(FTy, Name);
-
+static void setARCRuntimeFunctionLinkage(CodeGenModule &CGM,
+                                         llvm::Constant *RTF) {
   if (auto *F = dyn_cast<llvm::Function>(RTF)) {
     // If the target runtime doesn't naturally support ARC, emit weak
     // references to the runtime support library.  We don't really
     // permit this to fail, but we need a particular relocation style.
     if (!CGM.getLangOpts().ObjCRuntime.hasNativeARC() &&
         !CGM.getTriple().isOSBinFormatCOFF()) {
       F->setLinkage(llvm::Function::ExternalWeakLinkage);
-    } else if (Name == "objc_retain" || Name  == "objc_release") {
-      // If we have Native ARC, set nonlazybind attribute for these APIs for
-      // performance.
-      F->addFnAttr(llvm::Attribute::NonLazyBind);
     }
   }
-
-  return RTF;
 }
 
 /// 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::Constant *&fn,
-                                          StringRef fnName,
+                                          llvm::Intrinsic::ID IntID,
                                           bool isTailCall = false) {
   if (isa<llvm::ConstantPointerNull>(value))
     return value;
 
   if (!fn) {
-    llvm::FunctionType *fnType =
-      llvm::FunctionType::get(CGF.Int8PtrTy, CGF.Int8PtrTy, false);
-    fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
+    fn = CGF.CGM.getIntrinsic(IntID);
+    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
   }
 
   // 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);
   if (isTailCall)
     call->setTailCall();
 
   // 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::Constant *&fn,
-                                         StringRef fnName) {
+                                         llvm::Intrinsic::ID IntID) {
   if (!fn) {
-    llvm::FunctionType *fnType =
-      llvm::FunctionType::get(CGF.Int8PtrTy, CGF.Int8PtrPtrTy, false);
-    fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
+    fn = CGF.CGM.getIntrinsic(IntID);
+    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
   }
 
   // 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::Constant *&fn,
-                                          StringRef fnName,
+                                          llvm::Intrinsic::ID IntID,
                                           bool ignored) {
   assert(addr.getElementType() == value->getType());
 
   if (!fn) {
-    llvm::Type *argTypes[] = { CGF.Int8PtrPtrTy, CGF.Int8PtrTy };
-
-    llvm::FunctionType *fnType
-      = llvm::FunctionType::get(CGF.Int8PtrTy, argTypes, false);
-    fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
+    fn = CGF.CGM.getIntrinsic(IntID);
+    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
   }
 
   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::Constant *&fn,
-                                 StringRef fnName) {
+                                 llvm::Intrinsic::ID IntID) {
   assert(dst.getType() == src.getType());
 
   if (!fn) {
-    llvm::Type *argTypes[] = { CGF.Int8PtrPtrTy, CGF.Int8PtrPtrTy };
-
-    llvm::FunctionType *fnType
-      = llvm::FunctionType::get(CGF.Builder.getVoidTy(), argTypes, false);
-    fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
+    fn = CGF.CGM.getIntrinsic(IntID);
+    setARCRuntimeFunctionLinkage(CGF.CGM, fn);
   }
 
   llvm::Value *args[] = {
     CGF.Builder.CreateBitCast(dst.getPointer(), CGF.Int8PtrPtrTy),
     CGF.Builder.CreateBitCast(src.getPointer(), CGF.Int8PtrPtrTy)
   };
   CGF.EmitNounwindRuntimeCall(fn, args);
 }
 
+/// Perform an operation having the signature
+///   i8* (i8*)
+/// where a null input causes a no-op and returns null.
+static llvm::Value *emitObjCValueOperation(CodeGenFunction &CGF,
+                                           llvm::Value *value,
+                                           llvm::Type *returnType,
+                                           llvm::Constant *&fn,
+                                           StringRef fnName) {
+  if (isa<llvm::ConstantPointerNull>(value))
+    return value;
+
+  if (!fn) {
+    llvm::FunctionType *fnType =
+      llvm::FunctionType::get(CGF.Int8PtrTy, CGF.Int8PtrTy, false);
+    fn = CGF.CGM.CreateRuntimeFunction(fnType, fnName);
+  }
+
+  // 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);
+
+  // Cast the result back to the original type.
+  return CGF.Builder.CreateBitCast(call, origType);
+}
+
 /// Produce the code to do a retain.  Based on the type, calls one of:
 ///   call i8* \@objc_retain(i8* %value)
 ///   call i8* \@objc_retainBlock(i8* %value)
 llvm::Value *CodeGenFunction::EmitARCRetain(QualType type, llvm::Value *value) {
   if (type->isBlockPointerType())
     return EmitARCRetainBlock(value, /*mandatory*/ false);
   else
     return EmitARCRetainNonBlock(value);
 }
 
 /// Retain the given object, with normal retain semantics.
 ///   call i8* \@objc_retain(i8* %value)
 llvm::Value *CodeGenFunction::EmitARCRetainNonBlock(llvm::Value *value) {
   return emitARCValueOperation(*this, value, nullptr,
                                CGM.getObjCEntrypoints().objc_retain,
-                               "objc_retain");
+                               llvm::Intrinsic::objc_retain);
 }
 
 /// Retain the given block, with _Block_copy semantics.
 ///   call i8* \@objc_retainBlock(i8* %value)
 ///
 /// \param mandatory - If false, emit the call with metadata
 /// indicating that it's okay for the optimizer to eliminate this call
 /// if it can prove that the block never escapes except down the stack.
 llvm::Value *CodeGenFunction::EmitARCRetainBlock(llvm::Value *value,
                                                  bool mandatory) {
   llvm::Value *result
     = emitARCValueOperation(*this, value, nullptr,
                             CGM.getObjCEntrypoints().objc_retainBlock,
-                            "objc_retainBlock");
+                            llvm::Intrinsic::objc_retainBlock);
 
   // If the copy isn't mandatory, add !clang.arc.copy_on_escape to
   // tell the optimizer that it doesn't need to do this copy if the
   // block doesn't escape, where being passed as an argument doesn't
   // count as escaping.
   if (!mandatory && isa<llvm::Instruction>(result)) {
     llvm::CallInst *call
       = cast<llvm::CallInst>(result->stripPointerCasts());

 ///
 /// Yes, this function name is one character away from a different
 /// call with completely different semantics.
 llvm::Value *
 CodeGenFunction::EmitARCRetainAutoreleasedReturnValue(llvm::Value *value) {
   emitAutoreleasedReturnValueMarker(*this);
   return emitARCValueOperation(*this, value, nullptr,
               CGM.getObjCEntrypoints().objc_retainAutoreleasedReturnValue,
-                               "objc_retainAutoreleasedReturnValue");
+                           llvm::Intrinsic::objc_retainAutoreleasedReturnValue);
 }
 
 /// Claim a possibly-autoreleased return value at +0.  This is only
 /// valid to do in contexts which do not rely on the retain to keep
 /// the object valid for all of its uses; for example, when
 /// the value is ignored, or when it is being assigned to an
 /// __unsafe_unretained variable.
 ///
 ///   call i8* \@objc_unsafeClaimAutoreleasedReturnValue(i8* %value)
 llvm::Value *
 CodeGenFunction::EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value) {
   emitAutoreleasedReturnValueMarker(*this);
   return emitARCValueOperation(*this, value, nullptr,
               CGM.getObjCEntrypoints().objc_unsafeClaimAutoreleasedReturnValue,
-                               "objc_unsafeClaimAutoreleasedReturnValue");
+                     llvm::Intrinsic::objc_unsafeClaimAutoreleasedReturnValue);
 }
 
 /// 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::Constant *&fn = CGM.getObjCEntrypoints().objc_release;
   if (!fn) {
-    llvm::FunctionType *fnType =
-      llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
-    fn = createARCRuntimeFunction(CGM, fnType, "objc_release");
+    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_release);
+    setARCRuntimeFunctionLinkage(CGM, fn);
   }
 
   // Cast the argument to 'id'.
   value = Builder.CreateBitCast(value, Int8PtrTy);
 
   // Call objc_release.
   llvm::CallInst *call = EmitNounwindRuntimeCall(fn, value);
 

 ///   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::Constant *&fn = CGM.getObjCEntrypoints().objc_storeStrong;
   if (!fn) {
-    llvm::Type *argTypes[] = { Int8PtrPtrTy, Int8PtrTy };
-    llvm::FunctionType *fnType
-      = llvm::FunctionType::get(Builder.getVoidTy(), argTypes, false);
-    fn = createARCRuntimeFunction(CGM, fnType, "objc_storeStrong");
+    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_storeStrong);
+    setARCRuntimeFunctionLinkage(CGM, fn);
   }
 
   llvm::Value *args[] = {
     Builder.CreateBitCast(addr.getPointer(), Int8PtrPtrTy),
     Builder.CreateBitCast(value, Int8PtrTy)
   };
   EmitNounwindRuntimeCall(fn, args);
 
llvm::Value *CodeGenFunction::EmitARCStoreStrong(LValue dst,
   return newValue;
 }
 
 /// Autorelease the given object.
 ///   call i8* \@objc_autorelease(i8* %value)
 llvm::Value *CodeGenFunction::EmitARCAutorelease(llvm::Value *value) {
   return emitARCValueOperation(*this, value, nullptr,
                                CGM.getObjCEntrypoints().objc_autorelease,
-                               "objc_autorelease");
+                               llvm::Intrinsic::objc_autorelease);
 }
 
 /// Autorelease the given object.
 ///   call i8* \@objc_autoreleaseReturnValue(i8* %value)
 llvm::Value *
 CodeGenFunction::EmitARCAutoreleaseReturnValue(llvm::Value *value) {
   return emitARCValueOperation(*this, value, nullptr,
                             CGM.getObjCEntrypoints().objc_autoreleaseReturnValue,
-                               "objc_autoreleaseReturnValue",
+                               llvm::Intrinsic::objc_autoreleaseReturnValue,
                                /*isTailCall*/ true);
 }
 
 /// Do a fused retain/autorelease of the given object.
 ///   call i8* \@objc_retainAutoreleaseReturnValue(i8* %value)
 llvm::Value *
 CodeGenFunction::EmitARCRetainAutoreleaseReturnValue(llvm::Value *value) {
   return emitARCValueOperation(*this, value, nullptr,
                      CGM.getObjCEntrypoints().objc_retainAutoreleaseReturnValue,
-                               "objc_retainAutoreleaseReturnValue",
+                             llvm::Intrinsic::objc_retainAutoreleaseReturnValue,
                                /*isTailCall*/ true);
 }
 
 /// Do a fused retain/autorelease of the given object.
 ///   call i8* \@objc_retainAutorelease(i8* %value)
 /// or
 ///   %retain = call i8* \@objc_retainBlock(i8* %value)
 ///   call i8* \@objc_autorelease(i8* %retain)

 }
 
 /// Do a fused retain/autorelease of the given object.
 ///   call i8* \@objc_retainAutorelease(i8* %value)
 llvm::Value *
 CodeGenFunction::EmitARCRetainAutoreleaseNonBlock(llvm::Value *value) {
   return emitARCValueOperation(*this, value, nullptr,
                                CGM.getObjCEntrypoints().objc_retainAutorelease,
-                               "objc_retainAutorelease");
+                               llvm::Intrinsic::objc_retainAutorelease);
 }
 
 /// i8* \@objc_loadWeak(i8** %addr)
 /// Essentially objc_autorelease(objc_loadWeakRetained(addr)).
 llvm::Value *CodeGenFunction::EmitARCLoadWeak(Address addr) {
   return emitARCLoadOperation(*this, addr,
                               CGM.getObjCEntrypoints().objc_loadWeak,
-                              "objc_loadWeak");
+                              llvm::Intrinsic::objc_loadWeak);
 }
 
 /// i8* \@objc_loadWeakRetained(i8** %addr)
 llvm::Value *CodeGenFunction::EmitARCLoadWeakRetained(Address addr) {
   return emitARCLoadOperation(*this, addr,
                               CGM.getObjCEntrypoints().objc_loadWeakRetained,
-                              "objc_loadWeakRetained");
+                              llvm::Intrinsic::objc_loadWeakRetained);
 }
 
 /// i8* \@objc_storeWeak(i8** %addr, i8* %value)
 /// Returns %value.
 llvm::Value *CodeGenFunction::EmitARCStoreWeak(Address addr,
                                                llvm::Value *value,
                                                bool ignored) {
   return emitARCStoreOperation(*this, addr, value,
                                CGM.getObjCEntrypoints().objc_storeWeak,
-                               "objc_storeWeak", ignored);
+                               llvm::Intrinsic::objc_storeWeak, ignored);
 }
 
 /// i8* \@objc_initWeak(i8** %addr, i8* %value)
 /// Returns %value.  %addr is known to not have a current weak entry.
 /// Essentially equivalent to:
 ///   *addr = nil; objc_storeWeak(addr, value);
 void CodeGenFunction::EmitARCInitWeak(Address addr, llvm::Value *value) {
   // If we're initializing to null, just write null to memory; no need
   // to get the runtime involved.  But don't do this if optimization
   // is enabled, because accounting for this would make the optimizer
   // much more complicated.
   if (isa<llvm::ConstantPointerNull>(value) &&
       CGM.getCodeGenOpts().OptimizationLevel == 0) {
     Builder.CreateStore(value, addr);
     return;
   }
 
   emitARCStoreOperation(*this, addr, value,
                         CGM.getObjCEntrypoints().objc_initWeak,
-                        "objc_initWeak", /*ignored*/ true);
+                        llvm::Intrinsic::objc_initWeak, /*ignored*/ true);
 }
 
 /// void \@objc_destroyWeak(i8** %addr)
 /// Essentially objc_storeWeak(addr, nil).
 void CodeGenFunction::EmitARCDestroyWeak(Address addr) {
   llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_destroyWeak;
   if (!fn) {
-    llvm::FunctionType *fnType =
-      llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrPtrTy, false);
-    fn = createARCRuntimeFunction(CGM, fnType, "objc_destroyWeak");
+    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_destroyWeak);
+    setARCRuntimeFunctionLinkage(CGM, fn);
   }
 
   // Cast the argument to 'id*'.
   addr = Builder.CreateBitCast(addr, Int8PtrPtrTy);
 
   EmitNounwindRuntimeCall(fn, addr.getPointer());
 }
 
 /// void \@objc_moveWeak(i8** %dest, i8** %src)
 /// Disregards the current value in %dest.  Leaves %src pointing to nothing.
 /// Essentially (objc_copyWeak(dest, src), objc_destroyWeak(src)).
 void CodeGenFunction::EmitARCMoveWeak(Address dst, Address src) {
   emitARCCopyOperation(*this, dst, src,
                        CGM.getObjCEntrypoints().objc_moveWeak,
-                       "objc_moveWeak");
+                       llvm::Intrinsic::objc_moveWeak);
 }
 
 /// void \@objc_copyWeak(i8** %dest, i8** %src)
 /// Disregards the current value in %dest.  Essentially
 ///   objc_release(objc_initWeak(dest, objc_readWeakRetained(src)))
 void CodeGenFunction::EmitARCCopyWeak(Address dst, Address src) {
   emitARCCopyOperation(*this, dst, src,
                        CGM.getObjCEntrypoints().objc_copyWeak,
-                       "objc_copyWeak");
+                       llvm::Intrinsic::objc_copyWeak);
 }
 
 void CodeGenFunction::emitARCCopyAssignWeak(QualType Ty, Address DstAddr,
                                             Address SrcAddr) {
   llvm::Value *Object = EmitARCLoadWeakRetained(SrcAddr);
   Object = EmitObjCConsumeObject(Ty, Object);
   EmitARCStoreWeak(DstAddr, Object, false);
 }
 
 void CodeGenFunction::emitARCMoveAssignWeak(QualType Ty, Address DstAddr,
                                             Address SrcAddr) {
   llvm::Value *Object = EmitARCLoadWeakRetained(SrcAddr);
   Object = EmitObjCConsumeObject(Ty, Object);
   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::Constant *&fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPush;
   if (!fn) {
-    llvm::FunctionType *fnType =
-      llvm::FunctionType::get(Int8PtrTy, false);
-    fn = createARCRuntimeFunction(CGM, fnType, "objc_autoreleasePoolPush");
+    fn = CGM.getIntrinsic(llvm::Intrinsic::objc_autoreleasePoolPush);
+    setARCRuntimeFunctionLinkage(CGM, fn);
   }
 
   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);
 
-  llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPop;
+  if (getInvokeDest()) {
+    // Call the runtime method not the intrinsic if we are handling exceptions
+    llvm::Constant *&fn =
+      CGM.getObjCEntrypoints().objc_autoreleasePoolPopInvoke;
     if (!fn) {
       llvm::FunctionType *fnType =
         llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
-
-    // We don't want to use a weak import here; instead we should not
-    // fall into this path.
-    fn = createARCRuntimeFunction(CGM, fnType, "objc_autoreleasePoolPop");
+      fn = CGM.CreateRuntimeFunction(fnType, "objc_autoreleasePoolPop");
+      setARCRuntimeFunctionLinkage(CGM, fn);
     }
 
     // objc_autoreleasePoolPop can throw.
     EmitRuntimeCallOrInvoke(fn, value);
+  } else {
+    llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPop;
+    if (!fn) {
+      fn = CGM.getIntrinsic(llvm::Intrinsic::objc_autoreleasePoolPop);
+      setARCRuntimeFunctionLinkage(CGM, fn);
+    }
+
+    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.
 /// init is declared as: - (id) init; in its NSObject super class.
 ///
 llvm::Value *CodeGenFunction::EmitObjCMRRAutoreleasePoolPush() {
Runtime.GenerateMessageSend(*this, ReturnValueSlot(),
                                 InitSel, Receiver, Args);
   return InitRV.getScalarVal();
 }
 
 /// Allocate the given objc object.
 ///   call i8* \@objc_alloc(i8* %value)
 llvm::Value *CodeGenFunction::EmitObjCAlloc(llvm::Value *value,
                                             llvm::Type *resultType) {
-  return emitARCValueOperation(*this, value, resultType,
+  return emitObjCValueOperation(*this, value, resultType,
                                 CGM.getObjCEntrypoints().objc_alloc,
                                 "objc_alloc");
 }
 
 /// Allocate the given objc object.
 ///   call i8* \@objc_allocWithZone(i8* %value)
 llvm::Value *CodeGenFunction::EmitObjCAllocWithZone(llvm::Value *value,
                                                     llvm::Type *resultType) {
-  return emitARCValueOperation(*this, value, resultType,
+  return emitObjCValueOperation(*this, value, resultType,
                                 CGM.getObjCEntrypoints().objc_allocWithZone,
                                 "objc_allocWithZone");
 }
 
 /// Produce the code to do a primitive release.
 /// [tmp drain];
 void CodeGenFunction::EmitObjCMRRAutoreleasePoolPop(llvm::Value *Arg) {
   IdentifierInfo *II = &CGM.getContext().Idents.get("drain");
   Selector DrainSel = getContext().Selectors.getSelector(0, &II);
   CallArgList Args;

lib/CodeGen/CodeGenModule.h

struct ObjCEntrypoints {
   llvm::Constant *objc_alloc;
 
   /// void objc_allocWithZone(id);
   llvm::Constant *objc_allocWithZone;
 
   /// void objc_autoreleasePoolPop(void*);
   llvm::Constant *objc_autoreleasePoolPop;
 
+  /// void objc_autoreleasePoolPop(void*);
+  /// Note this method is used when we are using exception handling
+  llvm::Constant *objc_autoreleasePoolPopInvoke;
+
   /// void *objc_autoreleasePoolPush(void);
   llvm::Constant *objc_autoreleasePoolPush;
 
   /// id objc_autorelease(id);
   llvm::Constant *objc_autorelease;
 
   /// id objc_autoreleaseReturnValue(id);
   llvm::Constant *objc_autoreleaseReturnValue;

test/CodeGenObjC/arc-arm.m

 // RUN: %clang_cc1 -triple armv7-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple arm64-apple-ios -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s
 
 // <rdar://12438598>: use an autorelease marker on ARM64.
 
 id test0(void) {
   extern id test0_helper(void);
   // CHECK:      [[T0:%.*]] = call [[CC:(arm_aapcscc )?]]i8* @test0_helper()
   // CHECK-NEXT: ret i8* [[T0]]
   return test0_helper();
 }
 
 void test1(void) {
   extern id test1_helper(void);
   // CHECK:      [[T0:%.*]] = call [[CC]]i8* @test1_helper()
   // CHECK-NEXT: call void asm sideeffect "mov\09{{fp, fp|r7, r7}}\09\09// marker for objc_retainAutoreleaseReturnValue"
-  // CHECK-NEXT: [[T1:%.*]] = call [[CC]]i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call [[CC]]i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T1]],
-  // CHECK-NEXT: call [[CC]]void @objc_storeStrong(
+  // CHECK-NEXT: call [[CC]]void @llvm.objc.storeStrong(
   // CHECK-NEXT: ret void
   id x = test1_helper();
 }
 
 // rdar://problem/12133032
 @class A;
 A *test2(void) {
   extern A *test2_helper(void);

test/CodeGenObjC/arc-block-copy-escape.m

 // RUN: %clang_cc1 -fobjc-arc -fblocks -emit-llvm %s -o - | FileCheck %s
 
 typedef void (^block_t)(void);
 void use_block(block_t);
 void use_int(int);
 
 // rdar://problem/10211676
 
 void test0(int i) {
   block_t block = ^{ use_int(i); };
   // CHECK-LABEL:   define {{.*}}void @test0(
-  // CHECK:     call {{.*}}i8* @objc_retainBlock(i8* {{%.*}}) [[NUW:#[0-9]+]], !clang.arc.copy_on_escape
+  // CHECK:     call {{.*}}i8* @llvm.objc.retainBlock(i8* {{%.*}}) [[NUW:#[0-9]+]], !clang.arc.copy_on_escape
   // CHECK:     ret void
 }
 
 void test1(int i) {
   id block = ^{ use_int(i); };
   // CHECK-LABEL:   define {{.*}}void @test1(
-  // CHECK:     call {{.*}}i8* @objc_retainBlock(i8* {{%.*}}) [[NUW]]
+  // CHECK:     call {{.*}}i8* @llvm.objc.retainBlock(i8* {{%.*}}) [[NUW]]
   // CHECK-NOT: !clang.arc.copy_on_escape
   // CHECK:     ret void
 }
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/arc-blocks.m

 
 int (^test1(int x))(void) {
   // CHECK-LABEL:    define i32 ()* @test1(
   // CHECK:      [[X:%.*]] = alloca i32,
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
   // CHECK-NEXT: store i32 {{%.*}}, i32* [[X]]
   // CHECK:      [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to i32 ()*
   // CHECK-NEXT: [[T1:%.*]] = bitcast i32 ()* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]]) [[NUW:#[0-9]+]]
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) [[NUW:#[0-9]+]]
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i32 ()*
   // CHECK-NEXT: [[T4:%.*]] = bitcast i32 ()* [[T3]] to i8*
-  // CHECK-NEXT: [[T5:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[T4]]) [[NUW]]
+  // CHECK-NEXT: [[T5:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T4]]) [[NUW]]
   // CHECK-NEXT: [[T6:%.*]] = bitcast i8* [[T5]] to i32 ()*
   // CHECK-NEXT: ret i32 ()* [[T6]]
   return ^{ return x; };
 }
 
 void test2(id x) {
 // CHECK-LABEL:    define void @test2(
 // CHECK:      [[X:%.*]] = alloca i8*,
 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
-// CHECK-NEXT: [[PARM:%.*]] = call i8* @objc_retain(i8* {{%.*}})
+// CHECK-NEXT: [[PARM:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}})
 // CHECK-NEXT: store i8* [[PARM]], i8** [[X]]
 // CHECK-NEXT: [[SLOTREL:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]],
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]],
 // CHECK-NEXT: bitcast
 // CHECK-NEXT: call void @test2_helper(
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[SLOTREL]]
-// CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-// CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
 // CHECK-NEXT: ret void
   extern void test2_helper(id (^)(void));
   test2_helper(^{ return x; });
 
 // CHECK:    define linkonce_odr hidden void @__copy_helper_block_8_32s(i8*, i8*) unnamed_addr #{{[0-9]+}} {
 // CHECK:      [[T0:%.*]] = load i8*, i8**
 // CHECK-NEXT: [[SRC:%.*]] = bitcast i8* [[T0]] to [[BLOCK_T]]*
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8**
 // CHECK-NEXT: [[DST:%.*]] = bitcast i8* [[T0]] to [[BLOCK_T]]*
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[SRC]], i32 0, i32 5
 // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]]
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]]) [[NUW]]
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]]) [[NUW]]
 // CHECK-NEXT: ret void
 
 
 // CHECK:    define linkonce_odr hidden void @__destroy_helper_block_8_32s(i8*) unnamed_addr #{{[0-9]+}} {
 // CHECK:      [[T0:%.*]] = load i8*, i8**
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[BLOCK_T]]*
 // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[T1]], i32 0, i32 5
 // CHECK-NEXT: [[T3:%.*]] = load i8*, i8** [[T2]]
-// CHECK-NEXT: call void @objc_release(i8* [[T3]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T3]])
 // CHECK-NEXT: ret void
 }
 
 void test3(void (^sink)(id*)) {
   __strong id strong;
   sink(&strong);
 
   // CHECK-LABEL:    define void @test3(
   // CHECK:      [[SINK:%.*]] = alloca void (i8**)*
   // CHECK-NEXT: [[STRONG:%.*]] = alloca i8*
   // CHECK-NEXT: [[TEMP:%.*]] = alloca i8*
   // CHECK-NEXT: bitcast void (i8**)* {{%.*}} to i8*
-  // CHECK-NEXT: call i8* @objc_retain(
+  // CHECK-NEXT: call i8* @llvm.objc.retain(
   // CHECK-NEXT: bitcast i8*
   // CHECK-NEXT: store void (i8**)* {{%.*}}, void (i8**)** [[SINK]]
   // CHECK-NEXT: [[STRONGPTR1:%.*]] = bitcast i8** [[STRONG]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[STRONGPTR1]])
   // CHECK-NEXT: store i8* null, i8** [[STRONG]]
 
   // CHECK-NEXT: load void (i8**)*, void (i8**)** [[SINK]]
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: getelementptr
   // CHECK-NEXT: [[BLOCK:%.*]] = bitcast
   // CHECK-NEXT: [[V:%.*]] = load i8*, i8** [[STRONG]]
   // CHECK-NEXT: store i8* [[V]], i8** [[TEMP]]
   // CHECK-NEXT: [[F0:%.*]] = load i8*, i8**
   // CHECK-NEXT: [[F1:%.*]] = bitcast i8* [[F0]] to void (i8*, i8**)*
   // CHECK-NEXT: call void [[F1]](i8* [[BLOCK]], i8** [[TEMP]])
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[TEMP]]
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   // CHECK-NEXT: call void (...) @clang.arc.use(i8* [[V]]) [[NUW]]
   // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[STRONG]]
   // CHECK-NEXT: store i8* [[T1]], i8** [[STRONG]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T2]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
 
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[STRONG]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: [[STRONGPTR2:%.*]] = bitcast i8** [[STRONG]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[STRONGPTR2]])
 
   // CHECK-NEXT: load void (i8**)*, void (i8**)** [[SINK]]
   // CHECK-NEXT: bitcast
-  // CHECK-NEXT: call void @objc_release
+  // CHECK-NEXT: call void @llvm.objc.release
   // CHECK-NEXT: ret void
 
 }
 
 void test4(void) {
   id test4_source(void);
   void test4_helper(void (^)(void));
   __block id var = test4_source();
   test4_helper(^{ var = 0; });
 
   // CHECK-LABEL:    define void @test4()
   // CHECK:      [[VAR:%.*]] = alloca [[BYREF_T:%.*]],
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 2
   // 0x02000000 - has copy/dispose helpers strong
   // CHECK-NEXT: store i32 838860800, i32* [[T0]]
   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6
   // CHECK-NEXT: [[T0:%.*]] = call i8* @test4_source()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]]
   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6
   // 0x42800000 - has signature, copy/dispose helpers, as well as BLOCK_HAS_EXTENDED_LAYOUT
   // CHECK:      store i32 -1040187392,
   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
   // CHECK-NEXT: store i8* [[T0]], i8**
   // CHECK:      call void @test4_helper(
   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
   // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[SLOT]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK: ret void
 
   // CHECK-LABEL:    define internal void @__Block_byref_object_copy_(i8*, i8*) #{{[0-9]+}} {
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6
   // CHECK-NEXT: load i8*, i8**
   // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]*
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6
   // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[T1]]
   // CHECK-NEXT: store i8* [[T2]], i8** [[T0]]
   // CHECK-NEXT: store i8* null, i8** [[T1]]
 
   // CHECK-LABEL:    define internal void @__Block_byref_object_dispose_(i8*) #{{[0-9]+}} {
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 
   // CHECK-LABEL:    define internal void @__test4_block_invoke
   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[SLOT]], align 8
   // CHECK-NEXT: store i8* null, i8** [[SLOT]],
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: ret void
 
   // CHECK-LABEL:    define linkonce_odr hidden void @__copy_helper_block_8_32r(i8*, i8*) unnamed_addr #{{[0-9]+}} {
   // CHECK:      call void @_Block_object_assign(i8* {{%.*}}, i8* {{%.*}}, i32 8)
 
   // CHECK-LABEL:    define linkonce_odr hidden void @__destroy_helper_block_8_32r(i8*) unnamed_addr #{{[0-9]+}} {
   // CHECK:      call void @_Block_object_dispose(i8* {{%.*}}, i32 8)
 }
 
 void test5(void) {
   extern id test5_source(void);
   void test5_helper(void (^)(void));
   __unsafe_unretained id var = test5_source();
   test5_helper(^{ (void) var; });
 
   // CHECK-LABEL:    define void @test5()
   // CHECK:      [[VAR:%.*]] = alloca i8*
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
   // CHECK-NEXT: [[VARPTR1:%.*]] = bitcast i8** [[VAR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[VARPTR1]])
   // CHECK: [[T0:%.*]] = call i8* @test5_source()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T1]], i8** [[VAR]],
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   // 0x40800000 - has signature but no copy/dispose, as well as BLOCK_HAS_EXTENDED_LAYOUT
   // CHECK:      store i32 -1073741824, i32*
   // CHECK:      [[CAPTURE:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[VAR]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[CAPTURE]]
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to
   // CHECK: call void @test5_helper
   // CHECK-NEXT: [[VARPTR2:%.*]] = bitcast i8** [[VAR]] to i8*
void test6(void) {
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
   // CHECK-NEXT: [[VARPTR1:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 48, i8* [[VARPTR1]])
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 2
   // 0x02000000 - has copy/dispose helpers weak
   // CHECK-NEXT: store i32 1107296256, i32* [[T0]]
   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6
   // CHECK-NEXT: [[T0:%.*]] = call i8* @test6_source()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
-  // CHECK-NEXT: call i8* @objc_initWeak(i8** [[SLOT]], i8* [[T1]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[SLOT]], i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6
   // 0x42800000 - has signature, copy/dispose helpers, as well as BLOCK_HAS_EXTENDED_LAYOUT
   // CHECK:      store i32 -1040187392,
   // CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* %{{.*}}, i32 0, i32 4
 // CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @[[BLOCK_DESCRIPTOR_TMP9]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8
   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
   // CHECK-NEXT: store i8* [[T0]], i8**
   // CHECK:      call void @test6_helper(
   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
   // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** [[SLOT]])
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[SLOT]])
   // CHECK-NEXT: [[VARPTR2:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 48, i8* [[VARPTR2]])
   // CHECK-NEXT: ret void
 
   // CHECK-LABEL:    define internal void @__Block_byref_object_copy_.{{[0-9]+}}(i8*, i8*) #{{[0-9]+}} {
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6
   // CHECK-NEXT: load i8*, i8**
   // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]*
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6
-  // CHECK-NEXT: call void @objc_moveWeak(i8** [[T0]], i8** [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.moveWeak(i8** [[T0]], i8** [[T1]])
 
   // CHECK-LABEL:    define internal void @__Block_byref_object_dispose_.{{[0-9]+}}(i8*) #{{[0-9]+}} {
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[T0]])
 
   // CHECK-LABEL:    define internal void @__test6_block_invoke
   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6
-  // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[SLOT]], i8* null)
+  // CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[SLOT]], i8* null)
   // CHECK-NEXT: ret void
 }
 
 void test7(void) {
   id test7_source(void);
   void test7_helper(void (^)(void));
   void test7_consume(id);
   __weak id var = test7_source();
   test7_helper(^{ test7_consume(var); });
 
   // CHECK-LABEL:    define void @test7()
   // CHECK:      [[VAR:%.*]] = alloca i8*,
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
   // CHECK:      [[T0:%.*]] = call i8* @test7_source()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
-  // CHECK-NEXT: call i8* @objc_initWeak(i8** [[VAR]], i8* [[T1]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[VAR]], i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   // 0x42800000 - has signature, copy/dispose helpers, as well as BLOCK_HAS_EXTENDED_LAYOUT
   // CHECK:      store i32 -1040187392,
   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
-  // CHECK-NEXT: call void @objc_copyWeak(i8** [[SLOT]], i8** [[VAR]])
+  // CHECK-NEXT: call void @llvm.objc.copyWeak(i8** [[SLOT]], i8** [[VAR]])
   // CHECK:      call void @test7_helper(
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** {{%.*}})
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** [[VAR]])
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** {{%.*}})
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[VAR]])
   // CHECK: ret void
 
   // CHECK-LABEL:    define internal void @__test7_block_invoke
   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* {{%.*}}, i32 0, i32 5
-  // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_loadWeakRetained(i8** [[SLOT]])
+  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[SLOT]])
   // CHECK-NEXT: call void @test7_consume(i8* [[T0]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK: ret void
 
   // CHECK-LABEL:    define linkonce_odr hidden void @__copy_helper_block_8_32w(i8*, i8*) unnamed_addr #{{[0-9]+}} {
   // CHECK:      getelementptr
   // CHECK-NEXT: getelementptr
-  // CHECK-NEXT: call void @objc_copyWeak(
+  // CHECK-NEXT: call void @llvm.objc.copyWeak(
 
   // CHECK-LABEL:    define linkonce_odr hidden void @__destroy_helper_block_8_32w(i8*) unnamed_addr #{{[0-9]+}} {
   // CHECK:      getelementptr
-  // CHECK-NEXT: call void @objc_destroyWeak(
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(
 }
 
 @interface Test8 @end
 @implementation Test8
 - (void) test {
 // CHECK:    define internal void @"\01-[Test8 test]"
 // CHECK:      [[SELF:%.*]] = alloca [[TEST8:%.*]]*,
 // CHECK-NEXT: alloca i8*
return ^blocktype {
       extern id test9_produce(void);
       return test9_produce();
   }();
 
 // CHECK-LABEL:    define i8* @test9(
 // CHECK:      load i8*, i8** getelementptr
 // CHECK-NEXT: bitcast i8*
 // CHECK-NEXT: call i8* 
-// CHECK-NEXT: tail call i8* @objc_autoreleaseReturnValue
+// CHECK-NEXT: tail call i8* @llvm.objc.autoreleaseReturnValue
 // CHECK-NEXT: ret i8*
 
 // CHECK:      call i8* @test9_produce()
-// CHECK-NEXT: call i8* @objc_retain
+// CHECK-NEXT: call i8* @llvm.objc.retain
 // CHECK-NEXT: ret i8*
 }
 
 // rdar://problem/9814099
 // Test that we correctly initialize __block variables
 // when the initialization captures the variable.
 void test10a(void) {
   __block void (^block)(void) = ^{ block(); };
   // CHECK-LABEL:    define void @test10a()
   // CHECK:      [[BYREF:%.*]] = alloca [[BYREF_T:%.*]],
 
   // Zero-initialization before running the initializer.
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6
   // CHECK-NEXT: store void ()* null, void ()** [[T0]], align 8
 
   // Run the initializer as an assignment.
   // CHECK:      [[T0:%.*]] = bitcast void ()* {{%.*}} to i8*
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainBlock(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()*
   // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 1
   // CHECK-NEXT: [[T4:%.*]] = load [[BYREF_T]]*, [[BYREF_T]]** [[T3]]
   // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[T4]], i32 0, i32 6
   // CHECK-NEXT: [[T6:%.*]] = load void ()*, void ()** [[T5]], align 8
   // CHECK-NEXT: store void ()* {{%.*}}, void ()** [[T5]], align 8
   // CHECK-NEXT: [[T7:%.*]] = bitcast void ()* [[T6]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T7]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T7]])
 
   // Destroy at end of function.
   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[BYREF_T]]* [[BYREF]] to i8*
   // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
   // CHECK-NEXT: [[T1:%.*]] = load void ()*, void ()** [[SLOT]]
   // CHECK-NEXT: [[T2:%.*]] = bitcast void ()* [[T1]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T2]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
   // CHECK: ret void
 }
 
 // <rdar://problem/10402698>: do this copy and dispose with
 // objc_retainBlock/release instead of _Block_object_assign/destroy.
 // We can also use _Block_object_assign/destroy with
 // BLOCK_FIELD_IS_BLOCK as long as we don't pass BLOCK_BYREF_CALLER.
 
 // CHECK-LABEL: define internal void @__Block_byref_object_copy_.{{[0-9]+}}(i8*, i8*) #{{[0-9]+}} {
 // CHECK:      [[D0:%.*]] = load i8*, i8** {{%.*}}
 // CHECK-NEXT: [[D1:%.*]] = bitcast i8* [[D0]] to [[BYREF_T]]*
 // CHECK-NEXT: [[D2:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[D1]], i32 0, i32 6
 // CHECK-NEXT: [[S0:%.*]] = load i8*, i8** {{%.*}}
 // CHECK-NEXT: [[S1:%.*]] = bitcast i8* [[S0]] to [[BYREF_T]]*
 // CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[S1]], i32 0, i32 6
 // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[S2]], align 8
 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
 // CHECK-NEXT: store void ()* [[T3]], void ()** [[D2]], align 8
 // CHECK: ret void
 
 // CHECK-LABEL: define internal void @__Block_byref_object_dispose_.{{[0-9]+}}(i8*) #{{[0-9]+}} {
 // CHECK:      [[T0:%.*]] = load i8*, i8** {{%.*}}
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[BYREF_T]]*
 // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[T1]], i32 0, i32 6
 // CHECK-NEXT: [[T3:%.*]] = load void ()*, void ()** [[T2]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T4]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T4]])
 // CHECK-NEXT: ret void
 
 // Test that we correctly assign to __block variables when the
 // assignment captures the variable.
 void test10b(void) {
   __block void (^block)(void);
   block = ^{ block(); };
 
   // CHECK-LABEL:    define void @test10b()
   // CHECK:      [[BYREF:%.*]] = alloca [[BYREF_T:%.*]],
 
   // Zero-initialize.
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6
   // CHECK-NEXT: store void ()* null, void ()** [[T0]], align 8
 
   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6
 
   // The assignment.
   // CHECK:      [[T0:%.*]] = bitcast void ()* {{%.*}} to i8*
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainBlock(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()*
   // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 1
   // CHECK-NEXT: [[T4:%.*]] = load [[BYREF_T]]*, [[BYREF_T]]** [[T3]]
   // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[T4]], i32 0, i32 6
   // CHECK-NEXT: [[T6:%.*]] = load void ()*, void ()** [[T5]], align 8
   // CHECK-NEXT: store void ()* {{%.*}}, void ()** [[T5]], align 8
   // CHECK-NEXT: [[T7:%.*]] = bitcast void ()* [[T6]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T7]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T7]])
 
   // Destroy at end of function.
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[BYREF_T]]* [[BYREF]] to i8*
   // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
   // CHECK-NEXT: [[T1:%.*]] = load void ()*, void ()** [[SLOT]]
   // CHECK-NEXT: [[T2:%.*]] = bitcast void ()* [[T1]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T2]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
   // CHECK: ret void
 }
 
 // rdar://problem/10088932
 void test11_helper(id);
 void test11a(void) {
   int x;
   test11_helper(^{ (void) x; });
 
   // CHECK-LABEL:    define void @test11a()
   // CHECK:      [[X:%.*]] = alloca i32, align 4
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8
   // CHECK:      [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()*
   // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
   // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
   // CHECK-NEXT: call void @test11_helper(i8* [[T4]])
   // CHECK-NEXT: [[T5:%.*]] = bitcast void ()* [[T3]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T5]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]])
   // CHECK: ret void
 }
 void test11b(void) {
   int x;
   id b = ^{ (void) x; };
 
   // CHECK-LABEL:    define void @test11b()
   // CHECK:      [[X:%.*]] = alloca i32, align 4
   // CHECK-NEXT: [[B:%.*]] = alloca i8*, align 8
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8
   // CHECK:      [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()*
   // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
   // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
   // CHECK-NEXT: store i8* [[T4]], i8** [[B]], align 8
   // CHECK-NEXT: [[T5:%.*]] = load i8*, i8** [[B]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T5]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]])
   // CHECK: ret void
 }
 
 // rdar://problem/9979150
 @interface Test12
 @property (strong) void(^ablock)(void);
 @property (nonatomic, strong) void(^nblock)(void);
 @end
void test13(id x) {
   void (^b)(void) = (x ? ^{test13_helper(x);} : 0);
   test13_use(b);
 
   // CHECK-LABEL:    define void @test13(
   // CHECK:      [[X:%.*]] = alloca i8*, align 8
   // CHECK-NEXT: [[B:%.*]] = alloca void ()*, align 8
   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:.*]], align 8
   // CHECK-NEXT: [[CLEANUP_ACTIVE:%.*]] = alloca i1
-  // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* {{%.*}})
+  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}})
   // CHECK-NEXT: store i8* [[T0]], i8** [[X]], align 8
   // CHECK-NEXT: [[BPTR1:%.*]] = bitcast void ()** [[B]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[BPTR1]])
   // CHECK-NEXT: [[CLEANUP_ADDR:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]], align 8
   // CHECK-NEXT: [[T1:%.*]] = icmp ne i8* [[T0]], null
   // CHECK-NEXT: store i1 false, i1* [[CLEANUP_ACTIVE]]
   // CHECK-NEXT: br i1 [[T1]],
 
   // CHECK-NOT:  br
   // CHECK:      [[CAPTURE:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]], align 8
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T1]], i8** [[CAPTURE]], align 8
   // CHECK-NEXT: store i1 true, i1* [[CLEANUP_ACTIVE]]
   // CHECK-NEXT: bitcast [[BLOCK_T]]* [[BLOCK]] to void ()*
   // CHECK-NEXT: br label
   // CHECK:      br label
   // CHECK:      [[T0:%.*]] = phi void ()*
   // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
   // CHECK-NEXT: store void ()* [[T3]], void ()** [[B]], align 8
   // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]], align 8
   // CHECK-NEXT: call void @test13_use(void ()* [[T0]])
   // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 
   // CHECK-NEXT: [[T0:%.*]] = load i1, i1* [[CLEANUP_ACTIVE]]
   // CHECK-NEXT: br i1 [[T0]]
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[CLEANUP_ADDR]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: br label
 
   // CHECK:      [[BPTR2:%.*]] = bitcast void ()** [[B]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[BPTR2]])
   // CHECK-NEXT:      [[T0:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: ret void
 }
 
 // <rdar://problem/10907510>
 void test14() {
   void (^const x[1])(void) = { ^{} };
 }
 
id (^test17(id self, int which))(void) {
   }
   return (void*) 0;
 }
 // CHECK-LABEL:    define i8* ()* @test17(
 // CHECK:      [[RET:%.*]] = alloca i8* ()*, align
 // CHECK-NEXT: [[SELF:%.*]] = alloca i8*,
 // CHECK:      [[B0:%.*]] = alloca [[BLOCK:<.*>]], align
 // CHECK:      [[B1:%.*]] = alloca [[BLOCK]], align
-// CHECK:      [[T0:%.*]] = call i8* @objc_retain(i8*
+// CHECK:      [[T0:%.*]] = call i8* @llvm.objc.retain(i8*
 // CHECK-NEXT: store i8* [[T0]], i8** [[SELF]], align
 // CHECK-NOT:  objc_retain
 // CHECK-NOT:  objc_release
 // CHECK:      [[DESTROY:%.*]] = getelementptr inbounds [[BLOCK]], [[BLOCK]]* [[B0]], i32 0, i32 5
 // CHECK-NOT:  objc_retain
 // CHECK-NOT:  objc_release
 // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BLOCK]], [[BLOCK]]* [[B0]], i32 0, i32 5
 // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[SELF]], align
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-NEXT: store i8* [[T2]], i8** [[T0]],
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK]]* [[B0]] to i8* ()*
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* ()* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8* ()*
 // CHECK-NEXT: store i8* ()* [[T3]], i8* ()** [[RET]]
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[DESTROY]]
-// CHECK-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
 // CHECK-NEXT: store i32
 // CHECK-NEXT: br label
 // CHECK-NOT:  objc_retain
 // CHECK-NOT:  objc_release
 // CHECK:      [[DESTROY:%.*]] = getelementptr inbounds [[BLOCK]], [[BLOCK]]* [[B1]], i32 0, i32 5
 // CHECK-NOT:  objc_retain
 // CHECK-NOT:  objc_release
 // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BLOCK]], [[BLOCK]]* [[B1]], i32 0, i32 5
 // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[SELF]], align
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-NEXT: store i8* [[T2]], i8** [[T0]],
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK]]* [[B1]] to i8* ()*
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* ()* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8* ()*
 // CHECK-NEXT: store i8* ()* [[T3]], i8* ()** [[RET]]
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[DESTROY]]
-// CHECK-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
 // CHECK-NEXT: store i32
 // CHECK-NEXT: br label
 
 void test18(id x) {
 // CHECK-UNOPT-LABEL:    define void @test18(
 // CHECK-UNOPT:      [[X:%.*]] = alloca i8*,
 // CHECK-UNOPT-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
 // CHECK-UNOPT-NEXT: store i8* null, i8** [[X]]
-// CHECK-UNOPT-NEXT: call void @objc_storeStrong(i8** [[X]], 
+// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], 
 // CHECK-UNOPT-NEXT: [[SLOTREL:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-UNOPT: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 4
 // CHECK-UNOPT: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @[[BLOCK_DESCRIPTOR_TMP44]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8
 // CHECK-UNOPT:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-UNOPT-NEXT: [[T0:%.*]] = load i8*, i8** [[X]],
-// CHECK-UNOPT-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+// CHECK-UNOPT-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
 // CHECK-UNOPT-NEXT: store i8* [[T1]], i8** [[SLOT]],
 // CHECK-UNOPT-NEXT: bitcast
 // CHECK-UNOPT-NEXT: call void @test18_helper(
-// CHECK-UNOPT-NEXT: call void @objc_storeStrong(i8** [[SLOTREL]], i8* null) [[NUW:#[0-9]+]]
-// CHECK-UNOPT-NEXT: call void @objc_storeStrong(i8** [[X]], i8* null) [[NUW]]
+// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[SLOTREL]], i8* null) [[NUW:#[0-9]+]]
+// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* null) [[NUW]]
 // CHECK-UNOPT-NEXT: ret void
   extern void test18_helper(id (^)(void));
   test18_helper(^{ return x; });
 }
 
 // Ensure that we don't emit helper code in copy/dispose routines for variables
 // that are const-captured.
 void testUnsafeUnretainedLifetimeInCopyAndDestroyHelpers(id x, id y) {

 // rdar://13588325
 void test19_sink(void (^)(int));
 void test19(void (^b)(void)) {
 // CHECK-LABEL:    define void @test19(
 //   Prologue.
 // CHECK:      [[B:%.*]] = alloca void ()*,
 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
 // CHECK-NEXT: [[T0:%.*]] = bitcast void ()* {{%.*}} to i8*
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()*
 // CHECK-NEXT: store void ()* [[T2]], void ()** [[B]]
 
 //   Block setup.  We skip most of this.  Note the bare retain.
 // CHECK-NEXT: [[SLOTREL:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 4
 // CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @[[BLOCK_DESCRIPTOR_TMP48]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8
 // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]],
 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
 // CHECK-NEXT: store void ()* [[T3]], void ()** [[SLOT]],
 //   Call.
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void (i32)*
 // CHECK-NEXT: call void @test19_sink(void (i32)* [[T0]])
 
   test19_sink(^(int x) { b(); });
 
 //   Block teardown.
 // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[SLOTREL]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T1]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 
 //   Local cleanup.
 // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T1]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 
 // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @test20(
 // CHECK: [[XADDR:%.*]] = alloca i8*
 // CHECK-NEXT: [[BLOCK:%.*]] = alloca <[[BLOCKTY:.*]]>
-// CHECK-NEXT: [[RETAINEDX:%.*]] = call i8* @objc_retain(i8* %{{.*}})
+// CHECK-NEXT: [[RETAINEDX:%.*]] = call i8* @llvm.objc.retain(i8* %{{.*}})
 // CHECK-NEXT: store i8* [[RETAINEDX]], i8** [[XADDR]]
 // CHECK-NEXT: [[CAPTUREFIELD:%.*]] = getelementptr inbounds <[[BLOCKTY]]>, <[[BLOCKTY]]>* [[BLOCK]], i32 0, i32 5
 // CHECK: [[BLOCKCAPTURED:%.*]] = getelementptr inbounds <[[BLOCKTY]]>, <[[BLOCKTY]]>* [[BLOCK]], i32 0, i32 5
 // CHECK: [[CAPTURED:%.*]] = load i8*, i8** [[XADDR]]
 // CHECK: store i8* [[CAPTURED]], i8** [[BLOCKCAPTURED]]
 // CHECK: [[CAPTURE:%.*]] = load i8*, i8** [[CAPTUREFIELD]]
 // CHECK-NEXT: call void (...) @clang.arc.use(i8* [[CAPTURE]])
 // CHECK-NEXT: [[X:%.*]] = load i8*, i8** [[XADDR]]
-// CHECK-NEXT: call void @objc_release(i8* [[X]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[X]])
 // CHECK-NEXT: ret void
 
 // CHECK-UNOPT-LABEL: define void @test20(
 // CHECK-UNOPT: [[XADDR:%.*]] = alloca i8*
 // CHECK-UNOPT-NEXT: [[BLOCK:%.*]] = alloca <[[BLOCKTY:.*]]>
 // CHECK-UNOPT: [[CAPTUREFIELD:%.*]] = getelementptr inbounds <[[BLOCKTY]]>, <[[BLOCKTY]]>* [[BLOCK]], i32 0, i32 5
 // CHECK-UNOPT: [[BLOCKCAPTURED:%.*]] = getelementptr inbounds <[[BLOCKTY]]>, <[[BLOCKTY]]>* [[BLOCK]], i32 0, i32 5
 // CHECK-UNOPT: [[CAPTURED:%.*]] = load i8*, i8** [[XADDR]]
-// CHECK-UNOPT: [[RETAINED:%.*]] = call i8* @objc_retain(i8* [[CAPTURED]])
+// CHECK-UNOPT: [[RETAINED:%.*]] = call i8* @llvm.objc.retain(i8* [[CAPTURED]])
 // CHECK-UNOPT: store i8* [[RETAINED]], i8** [[BLOCKCAPTURED]]
-// CHECK-UNOPT: call void @objc_storeStrong(i8** [[CAPTUREFIELD]], i8* null)
+// CHECK-UNOPT: call void @llvm.objc.storeStrong(i8** [[CAPTUREFIELD]], i8* null)
 
 void test20_callee(void (^)());
 void test20(const id x) {
   test20_callee(^{ (void)x; });
 }
 
 // CHECK: attributes [[NUW]] = { nounwind }
 // CHECK-UNOPT: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/arc-bridged-cast.m

void bridge_transfer_from_cf(int *i) {
   id obj1 = (__bridge_transfer id)CFCreateSomething();
   // CHECK-NOT: retain
   // CHECK: store i32 11
   *i = 11;
   // CHECK: call i8* @CFCreateSomething()
   // CHECK-NOT: retain
   // CHECK: store i32 13
   (void)(__bridge_transfer id)CFCreateSomething(), *i = 13;
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: store i32 17
   *i = 17;
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: call void @llvm.lifetime.end
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @bridge_from_cf
 void bridge_from_cf(int *i) {
   // CHECK: store i32 7
   *i = 7;
   // CHECK: call i8* @CFCreateSomething()
   id obj1 = (__bridge id)CFCreateSomething();
-  // CHECK: objc_retainAutoreleasedReturnValue
+  // CHECK: llvm.objc.retainAutoreleasedReturnValue
   // CHECK: store i32 11
   *i = 11;
   // CHECK: call i8* @CFCreateSomething()
   // CHECK-NOT: release
   // CHECK: store i32 13
   (void)(__bridge id)CFCreateSomething(), *i = 13;
   // CHECK: store i32 17
   *i = 17;
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: call void @llvm.lifetime.end
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @bridge_retained_of_cf
 void bridge_retained_of_cf(int *i) {
   *i = 7;
   // CHECK: call i8* @CreateSomething()
   CFTypeRef cf1 = (__bridge_retained CFTypeRef)CreateSomething();
-  // CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
   // CHECK: store i32 11
   *i = 11;
   // CHECK: call i8* @CreateSomething()
   (__bridge_retained CFTypeRef)CreateSomething(), *i = 13;
-  // CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
   // CHECK: store i32 13
   // CHECK: store i32 17
   *i = 17;
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: call void @llvm.lifetime.end
   // CHECK-NEXT: ret void
 }
 
void bridge_of_cf(int *i) {
   *i = 17;
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: call void @llvm.lifetime.end
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define %struct.__CFString* @bridge_of_paren_expr()
 CFStringRef bridge_of_paren_expr() {
-  // CHECK-NOT: call i8* @objc_retainAutoreleasedReturnValue(
-  // CHECK-NOT: call void @objc_release(
+  // CHECK-NOT: call i8* @llvm.objc.retainAutoreleasedReturnValue(
+  // CHECK-NOT: call void @llvm.objc.release(
   CFStringRef r = (__bridge CFStringRef)(CreateNSString());
   r = (__bridge CFStringRef)((NSString *)(CreateNSString()));
   return r;
 }

test/CodeGenObjC/arc-exceptions.m

void test0(void) {
   }
 }
 // CHECK-LABEL: define void @test0()
 // CHECK:      [[E:%.*]] = alloca [[ETY:%.*]]*, align 8
 // CHECK-NEXT: invoke void @test0_helper()
 // CHECK:      [[T0:%.*]] = call i8* @objc_begin_catch(
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[ETY]]*
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[ETY]]* [[T1]] to i8*
-// CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retain(i8* [[T2]]) [[NUW:#[0-9]+]]
+// CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.retain(i8* [[T2]]) [[NUW:#[0-9]+]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to [[ETY]]*
 // CHECK-NEXT: store [[ETY]]* [[T4]], [[ETY]]** [[E]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[ETY]]** [[E]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null) [[NUW]]
 // CHECK-NEXT: call void @objc_end_catch() [[NUW]]
 
 void test1_helper(void);
 void test1(void) {
   @try {
     test1_helper();
   } @catch (__weak Ety *e) {
   }
 }
 // CHECK-LABEL: define void @test1()
 // CHECK:      [[E:%.*]] = alloca [[ETY:%.*]]*, align 8
 // CHECK-NEXT: invoke void @test1_helper()
 // CHECK:      [[T0:%.*]] = call i8* @objc_begin_catch(
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[ETY]]*
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[ETY]]** [[E]] to i8**
 // CHECK-NEXT: [[T3:%.*]] = bitcast [[ETY]]* [[T1]] to i8*
-// CHECK-NEXT: call i8* @objc_initWeak(i8** [[T2]], i8* [[T3]]) [[NUW]]
+// CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[T2]], i8* [[T3]]) [[NUW]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[ETY]]** [[E]] to i8**
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[T0]]) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[T0]]) [[NUW]]
 // CHECK-NEXT: call void @objc_end_catch() [[NUW]]
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/arc-foreach.m

 // CHECK-LP64-OPT: [[STATE:%.*]] = alloca [[STATE_T:%.*]], align 8
 // CHECK-LP64-OPT-NEXT: [[BUFFER:%.*]] = alloca [16 x i8*], align 8
 // CHECK-LP64-OPT-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8
 
 // Initialize 'array'.
 // CHECK-LP64-NEXT: store [[ARRAY_T]]* null, [[ARRAY_T]]** [[ARRAY]]
 // CHECK-LP64-NEXT: [[ZERO:%.*]] = bitcast [[ARRAY_T]]** [[ARRAY]] to i8**
 // CHECK-LP64-NEXT: [[ONE:%.*]] = bitcast [[ARRAY_T]]* {{%.*}} to i8*
-// CHECK-LP64-NEXT: call void @objc_storeStrong(i8** [[ZERO]], i8* [[ONE]]) [[NUW:#[0-9]+]]
+// CHECK-LP64-NEXT: call void @llvm.objc.storeStrong(i8** [[ZERO]], i8* [[ONE]]) [[NUW:#[0-9]+]]
 
 // Initialize the fast enumaration state.
 // CHECK-LP64-NEXT: [[T0:%.*]] = bitcast [[STATE_T]]* [[STATE]] to i8*
 // CHECK-LP64-NEXT: call void @llvm.memset.p0i8.i64(i8* align 8 [[T0]], i8 0, i64 64, i1 false)
 
 // Evaluate the collection expression and retain.
 // CHECK-LP64-NEXT: [[T0:%.*]] = load [[ARRAY_T]]*, [[ARRAY_T]]** [[ARRAY]], align 8
 // CHECK-LP64-NEXT: [[T1:%.*]] = bitcast [[ARRAY_T]]* [[T0]] to i8*
-// CHECK-LP64-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-LP64-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-LP64-NEXT: [[SAVED_ARRAY:%.*]] = bitcast i8* [[T2]] to [[ARRAY_T]]*
 
 // Call the enumeration method.
 // CHECK-LP64-NEXT: [[T0:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
 // CHECK-LP64-NEXT: [[T1:%.*]] = bitcast [[ARRAY_T]]* [[SAVED_ARRAY]] to i8*
 // CHECK-LP64-NEXT: [[SIZE:%.*]] = call i64 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i64 (i8*, i8*, [[STATE_T]]*, [16 x i8*]*, i64)*)(i8* [[T1]], i8* [[T0]], [[STATE_T]]* [[STATE]], [16 x i8*]* [[BUFFER]], i64 16)
 
 // Check for a nonzero result.
 // CHECK-LP64-NEXT: [[T0:%.*]] = icmp eq i64 [[SIZE]], 0
 // CHECK-LP64-NEXT: br i1 [[T0]]
 
 // CHECK-LP64:      [[T0:%.*]] = getelementptr inbounds [[STATE_T]], [[STATE_T]]* [[STATE]], i32 0, i32 1
 // CHECK-LP64-NEXT: [[T1:%.*]] = load i8**, i8*** [[T0]]
 // CHECK-LP64-NEXT: [[T2:%.*]] = getelementptr i8*, i8** [[T1]], i64
 // CHECK-LP64-NEXT: [[T3:%.*]] = load i8*, i8** [[T2]]
 // CHECK-LP64-NEXT: store i8* [[T3]], i8** [[X]]
 
 // CHECK-LP64:      [[D0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-LP64:      [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-LP64-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
-// CHECK-LP64-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-LP64-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-LP64-NEXT: store i8* [[T2]], i8** [[T0]]
 // CHECK-LP64-NEXT: [[BLOCK1:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]]
 // CHECK-LP64-NEXT: call void @use_block(void ()* [[BLOCK1]])
-// CHECK-LP64-NEXT: call void @objc_storeStrong(i8** [[D0]], i8* null)
+// CHECK-LP64-NEXT: call void @llvm.objc.storeStrong(i8** [[D0]], i8* null)
 // CHECK-LP64-NOT:  call void (...) @clang.arc.use(i8* [[CAPTURE]])
 
 // CHECK-LP64-OPT: [[D0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i64 0, i32 5
 // CHECK-LP64-OPT: [[CAPTURE:%.*]] = load i8*, i8** [[D0]]
 // CHECK-LP64-OPT: call void (...) @clang.arc.use(i8* [[CAPTURE]])
 
 // CHECK-LP64:      [[T0:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
 // CHECK-LP64-NEXT: [[T1:%.*]] = bitcast [[ARRAY_T]]* [[SAVED_ARRAY]] to i8*
 // CHECK-LP64-NEXT: [[SIZE:%.*]] = call i64 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i64 (i8*, i8*, [[STATE_T]]*, [16 x i8*]*, i64)*)(i8* [[T1]], i8* [[T0]], [[STATE_T]]* [[STATE]], [16 x i8*]* [[BUFFER]], i64 16)
 
 // Release the array.
 // CHECK-LP64:      [[T0:%.*]] = bitcast [[ARRAY_T]]* [[SAVED_ARRAY]] to i8*
-// CHECK-LP64-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-LP64-NEXT: call void @llvm.objc.release(i8* [[T0]])
 
 // Destroy 'array'.
 // CHECK-LP64:      [[T0:%.*]] = bitcast [[ARRAY_T]]** [[ARRAY]] to i8**
-// CHECK-LP64-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK-LP64-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK-LP64-NEXT: ret void
 
 // CHECK-LP64-LABEL:    define internal void @__test0_block_invoke
 // CHECK-LP64:      [[BLOCK:%.*]] = bitcast i8* {{%.*}} to [[BLOCK_T]]*
 // CHECK-LP64-NOT:  ret
 // CHECK-LP64:      [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-LP64-NEXT: [[T2:%.*]] = load i8*, i8** [[T0]], align 8 
 // CHECK-LP64-NEXT: call void @use(i8* [[T2]])

 // CHECK-LP64-NEXT: [[STATE:%.*]] = alloca [[STATE_T:%.*]],
 // CHECK-LP64-NEXT: alloca [16 x i8*], align 8
 // CHECK-LP64-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
 
 // CHECK-LP64:      [[T0:%.*]] = getelementptr inbounds [[STATE_T]], [[STATE_T]]* [[STATE]], i32 0, i32 1
 // CHECK-LP64-NEXT: [[T1:%.*]] = load i8**, i8*** [[T0]]
 // CHECK-LP64-NEXT: [[T2:%.*]] = getelementptr i8*, i8** [[T1]], i64
 // CHECK-LP64-NEXT: [[T3:%.*]] = load i8*, i8** [[T2]]
-// CHECK-LP64-NEXT: call i8* @objc_initWeak(i8** [[X]], i8* [[T3]])
+// CHECK-LP64-NEXT: call i8* @llvm.objc.initWeak(i8** [[X]], i8* [[T3]])
 
 // CHECK-LP64:      [[D0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 // CHECK-LP64:      [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
-// CHECK-LP64-NEXT: call void @objc_copyWeak(i8** [[T0]], i8** [[X]])
+// CHECK-LP64-NEXT: call void @llvm.objc.copyWeak(i8** [[T0]], i8** [[X]])
 // CHECK-LP64-NEXT: [[T1:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to
 // CHECK-LP64: call void @use_block
-// CHECK-LP64-NEXT: call void @objc_destroyWeak(i8** [[D0]])
-// CHECK-LP64-NEXT: call void @objc_destroyWeak(i8** [[X]])
+// CHECK-LP64-NEXT: call void @llvm.objc.destroyWeak(i8** [[D0]])
+// CHECK-LP64-NEXT: call void @llvm.objc.destroyWeak(i8** [[X]])
 
 // rdar://problem/9817306
 @interface Test2
 - (NSArray *) array;
 @end
 void test2(Test2 *a) {
   for (id x in a.array) {
     use(x);
   }
 }
 
 // CHECK-LP64-LABEL:    define void @test2(
 // CHECK-LP64:      [[T0:%.*]] = call [[ARRAY_T]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to [[ARRAY_T]]* (i8*, i8*)*)(
 // CHECK-LP64-NEXT: [[T1:%.*]] = bitcast [[ARRAY_T]]* [[T0]] to i8*
-// CHECK-LP64-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-LP64-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-LP64-NEXT: [[COLL:%.*]] = bitcast i8* [[T2]] to [[ARRAY_T]]*
 
 // Make sure it's not immediately released before starting the iteration.
 // CHECK-LP64-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
 // CHECK-LP64-NEXT: [[T0:%.*]] = bitcast [[ARRAY_T]]* [[COLL]] to i8*
 // CHECK-LP64-NEXT: @objc_msgSend
 
 // This bitcast is for the mutation check.
 // CHECK-LP64:      [[T0:%.*]] = bitcast [[ARRAY_T]]* [[COLL]] to i8*
 // CHECK-LP64-NEXT: @objc_enumerationMutation
 
 // This bitcast is for the 'next' message send.
 // CHECK-LP64:      [[T0:%.*]] = bitcast [[ARRAY_T]]* [[COLL]] to i8*
 // CHECK-LP64-NEXT: @objc_msgSend
 
 // This bitcast is for the final release.
 // CHECK-LP64:      [[T0:%.*]] = bitcast [[ARRAY_T]]* [[COLL]] to i8*
-// CHECK-LP64-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-LP64-NEXT: call void @llvm.objc.release(i8* [[T0]])
 
 
 // Check that the 'continue' label is positioned appropriately
 // relative to the collection clenaup.
 void test3(NSArray *array) {
   for (id x in array) {
     if (!x) continue;
     use(x);

 // CHECK-LP64-LABEL: define internal void @"\01-[I1 foo2]"(
 // CHECK-LP64:         [[SELF_ADDR:%.*]] = alloca [[TY:%.*]]*,
 // CHECK-LP64:         [[BLOCK:%.*]] = alloca <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, [[TY]]* }>,
 // CHECK-LP64:         store [[TY]]* %self, [[TY]]** [[SELF_ADDR]]
 // CHECK-LP64:         [[T0:%.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, [[TY]]* }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, [[TY]]* }>* [[BLOCK]], i32 0, i32 5
 // CHECK-LP64:         [[BC:%.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, [[TY]]* }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, [[TY]]* }>* [[BLOCK]], i32 0, i32 5
 // CHECK-LP64:         [[T1:%.*]] = load [[TY]]*, [[TY]]** [[SELF_ADDR]]
 // CHECK-LP64:         [[T2:%.*]] = bitcast [[TY]]* [[T1]] to i8*
-// CHECK-LP64:         call i8* @objc_retain(i8* [[T2]])
+// CHECK-LP64:         call i8* @llvm.objc.retain(i8* [[T2]])
 
 // CHECK-LP64-OPT-LABEL: define internal void @"\01-[I1 foo2]"(
 // CHECK-LP64-OPT: [[TY:%.*]]* %self
 // CHECK-LP64-OPT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
 // CHECK-LP64-OPT: [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i64 0, i32 5
 
 // CHECK-LP64:         [[T5:%.*]] = bitcast [[TY]]** [[T0]] to i8**
-// CHECK-LP64:         call void @objc_storeStrong(i8** [[T5]], i8* null)
+// CHECK-LP64:         call void @llvm.objc.storeStrong(i8** [[T5]], i8* null)
 // CHECK-LP64-NOT:     call void (...) @clang.arc.use([[TY]]* [[T5]])
 // CHECK-LP64:         switch i32 {{%.*}}, label %[[UNREACHABLE:.*]] [
 // CHECK-LP64-NEXT:      i32 0, label %[[CLEANUP_CONT:.*]]
 // CHECK-LP64-NEXT:      i32 2, label %[[FORCOLL_END:.*]]
 // CHECK-LP64-NEXT:    ]
 
 // CHECK-LP64-OPT: [[T5:%.*]] = load [[TY]]*, [[TY]]** [[T0]]
 // CHECK-LP64-OPT: call void (...) @clang.arc.use([[TY]]* [[T5]])

test/CodeGenObjC/arc-i386.m

id test0(void) {
   return test0_helper();
 }
 
 // CHECK-LABEL: define void @test1()
 void test1(void) {
   extern id test1_helper(void);
   // CHECK:      [[T0:%.*]] = call i8* @test1_helper()
   // CHECK-NEXT: call void asm sideeffect "mov
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T1]],
-  // CHECK-NEXT: call void @objc_storeStrong(
+  // CHECK-NEXT: call void @llvm.objc.storeStrong(
   // CHECK-NEXT: ret void
   id x = test1_helper();
 }
 
 // rdar://problem/12133032
 // CHECK-LABEL: define {{.*}} @test2()
 @class A;
 A *test2(void) {

test/CodeGenObjC/arc-linetable-autorelease.m

 @implementation AppDelegate : NSObject {}
 - (NSBezierPath *)_createBezierPathWithWidth:(CGFloat)width height:(CGFloat)height radius:(CGFloat)radius lineWidth:(CGFloat)lineWidth
 {
   NSRect rect = NSMakeRect(0, 0, width, height);
   NSBezierPath *path = [NSBezierPath bezierPathWithRoundedRect:rect xRadius:radius yRadius:radius];
   CGFloat pattern[2];
   // CHECK: define {{.*}}_createBezierPathWithWidth
   // CHECK: load {{.*}} %path, align {{.*}}, !dbg ![[RET:[0-9]+]]
-  // CHECK: call void @objc_storeStrong{{.*}} !dbg ![[ARC:[0-9]+]]
-  // CHECK: call {{.*}} @objc_autoreleaseReturnValue{{.*}} !dbg ![[ARC]]
+  // CHECK: call void @llvm.objc.storeStrong{{.*}} !dbg ![[ARC:[0-9]+]]
+  // CHECK: call {{.*}} @llvm.objc.autoreleaseReturnValue{{.*}} !dbg ![[ARC]]
   // CHECK: ret {{.*}} !dbg ![[ARC]]
   // CHECK: ![[RET]] = !DILocation(line: [[@LINE+1]], scope: !{{.*}})
   return path;
   // CHECK: ![[ARC]] = !DILocation(line: [[@LINE+1]], scope: !{{.*}})
 }
 @end

test/CodeGenObjC/arc-linetable.m

 // RUN: %clang_cc1 -emit-llvm -fblocks -fobjc-arc -debug-info-kind=standalone -dwarf-version=4 -disable-llvm-passes -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
 
 // Legend: EXP = Return expression, RET = ret instruction
 
 // CHECK: define {{.*}}testNoSideEffect
-// CHECK: call void @objc_storeStrong{{.*}}
-// CHECK: call void @objc_storeStrong{{.*}} !dbg ![[RET1:[0-9]+]]
+// CHECK: call void @llvm.objc.storeStrong{{.*}}
+// CHECK: call void @llvm.objc.storeStrong{{.*}} !dbg ![[RET1:[0-9]+]]
 // CHECK: ret {{.*}} !dbg ![[RET1]]
 
 // CHECK: define {{.*}}testNoCleanup
 // CHECK: ret {{.*}} !dbg ![[RET2:[0-9]+]]
 
 // CHECK: define {{.*}}testSideEffect
 // CHECK: @objc_msgSend{{.*}} !dbg ![[MSG3:[0-9]+]]
 // CHECK: ret {{.*}} !dbg ![[RET3:[0-9]+]]
 
 // CHECK: define {{.*}}testMultiline
 // CHECK: @objc_msgSend{{.*}} !dbg ![[MSG4:[0-9]+]]
 // CHECK: load{{.*}} !dbg ![[EXP4:[0-9]+]]
 // CHECK: ret {{.*}} !dbg ![[RET4:[0-9]+]]
 
 // CHECK: define {{.*}}testVoid
-// CHECK: call void @objc_storeStrong{{.*}}
-// CHECK: call void @objc_storeStrong{{.*}} !dbg ![[RET5:[0-9]+]]
+// CHECK: call void @llvm.objc.storeStrong{{.*}}
+// CHECK: call void @llvm.objc.storeStrong{{.*}} !dbg ![[RET5:[0-9]+]]
 // CHECK: ret {{.*}} !dbg ![[RET5]]
 
 // CHECK: define {{.*}}testVoidNoReturn
 // CHECK: @objc_msgSend{{.*}} !dbg ![[MSG6:[0-9]+]]
 // CHECK: ret {{.*}} !dbg ![[RET6:[0-9]+]]
 
 // CHECK: define {{.*}}testNoCleanupSideEffect
 // CHECK: @objc_msgSend{{.*}} !dbg ![[MSG7:[0-9]+]]
 // CHECK: ret {{.*}} !dbg ![[RET7:[0-9]+]]
 
 // CHECK: define {{.*}}testCleanupVoid
 // CHECK: icmp ne {{.*}}!dbg ![[SKIP1:[0-9]+]]
 // CHECK: store i32 0, i32* {{.*}}, !dbg ![[RET8:[0-9]+]]
-// CHECK: @objc_storeStrong{{.*}}, !dbg ![[RET8]]
+// CHECK: @llvm.objc.storeStrong{{.*}}, !dbg ![[RET8]]
 // CHECK: ret {{.*}} !dbg ![[RET8]]
 
 typedef signed char BOOL;
 
 @interface NSObject
 + (id)alloc;
 - (id)init;
 - (id)retain;

test/CodeGenObjC/arc-literals.m

 // CHECK: c"numberWithChar:\00"
 // CHECK: c"arrayWithObjects:count:\00"
 // CHECK: c"dictionaryWithObjects:forKeys:count:\00"
 // CHECK: c"prop\00"
 
 // CHECK-LABEL: define void @test_numeric()
 void test_numeric() {
   // CHECK: {{call.*objc_msgSend.*i32 17}}
-  // CHECK: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
   id ilit = @17;
   // CHECK: {{call.*objc_msgSend.*i32 25}}
-  // CHECK: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
   id ulit = @25u;
   // CHECK: {{call.*objc_msgSend.*i64 42}}
-  // CHECK: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
   id ulllit = @42ull;
   // CHECK: {{call.*objc_msgSend.*i8 signext 97}}
-  // CHECK: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
   id charlit = @'a';
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @test_array
 void test_array(id a, id b) {
   // CHECK: [[A:%.*]] = alloca i8*,
   // CHECK: [[B:%.*]] = alloca i8*,
 
   // Retaining parameters
-  // CHECK: call i8* @objc_retain(i8*
-  // CHECK: call i8* @objc_retain(i8*
+  // CHECK: call i8* @llvm.objc.retain(i8*
+  // CHECK: call i8* @llvm.objc.retain(i8*
 
   // Constructing the array
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS:%[A-Za-z0-9]+]], i64 0, i64 0
   // CHECK-NEXT: [[V0:%.*]] = load i8*, i8** [[A]],
   // CHECK-NEXT: store i8* [[V0]], i8** [[T0]]
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 1
   // CHECK-NEXT: [[V1:%.*]] = load i8*, i8** [[B]],
   // CHECK-NEXT: store i8* [[V1]], i8** [[T0]]
 
   // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]*, [[CLASS_T:%.*]]** @"OBJC_CLASSLIST
   // CHECK-NEXT: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8*
   // CHECK-NEXT: [[T2:%.*]] = bitcast [2 x i8*]* [[OBJECTS]] to i8**
   // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast ({{.*@objc_msgSend.*}})(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i64 2)
-  // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T3]])
+  // CHECK-NEXT: [[T4:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T3]])
   // CHECK: call void (...) @clang.arc.use(i8* [[V0]], i8* [[V1]])
   id arr = @[a, b];
 
-  // CHECK: call void @objc_release
-  // CHECK: call void @objc_release
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
+  // CHECK: call void @llvm.objc.release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @test_dictionary
 void test_dictionary(id k1, id o1, id k2, id o2) {
   // CHECK: [[K1:%.*]] = alloca i8*,
   // CHECK: [[O1:%.*]] = alloca i8*,
   // CHECK: [[K2:%.*]] = alloca i8*,
   // CHECK: [[O2:%.*]] = alloca i8*,
 
   // Retaining parameters
-  // CHECK: call i8* @objc_retain(i8*
-  // CHECK: call i8* @objc_retain(i8*
-  // CHECK: call i8* @objc_retain(i8*
-  // CHECK: call i8* @objc_retain(i8*
+  // CHECK: call i8* @llvm.objc.retain(i8*
+  // CHECK: call i8* @llvm.objc.retain(i8*
+  // CHECK: call i8* @llvm.objc.retain(i8*
+  // CHECK: call i8* @llvm.objc.retain(i8*
 
   // Constructing the arrays
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[KEYS:%[A-Za-z0-9]+]], i64 0, i64 0
   // CHECK-NEXT: [[V0:%.*]] = load i8*, i8** [[K1]],
   // CHECK-NEXT: store i8* [[V0]], i8** [[T0]]
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS:%[A-Za-z0-9]+]], i64 0, i64 0
   // CHECK-NEXT: [[V1:%.*]] = load i8*, i8** [[O1]],
   // CHECK-NEXT: store i8* [[V1]], i8** [[T0]]
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[KEYS]], i64 0, i64 1
   // CHECK-NEXT: [[V2:%.*]] = load i8*, i8** [[K2]],
   // CHECK-NEXT: store i8* [[V2]], i8** [[T0]]
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 1
   // CHECK-NEXT: [[V3:%.*]] = load i8*, i8** [[O2]],
   // CHECK-NEXT: store i8* [[V3]], i8** [[T0]]
 
   // Constructing the dictionary
   // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]*, [[CLASS_T:%.*]]** @"OBJC_CLASSLIST
   // CHECK-NEXT: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8*
   // CHECK-NEXT: [[T2:%.*]] = bitcast [2 x i8*]* [[OBJECTS]] to i8**
   // CHECK-NEXT: [[T3:%.*]] = bitcast [2 x i8*]* [[KEYS]] to i8**
   // CHECK-NEXT: [[T4:%.*]] = call i8* bitcast ({{.*@objc_msgSend.*}})(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i8** [[T3]], i64 2)
-  // CHECK-NEXT: [[T5:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T4]])
+  // CHECK-NEXT: [[T5:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T4]])
   // CHECK-NEXT: call void (...) @clang.arc.use(i8* [[V0]], i8* [[V1]], i8* [[V2]], i8* [[V3]])
 
   id dict = @{ k1 : o1, k2 : o2 };
 
-  // CHECK: call void @objc_release
-  // CHECK: call void @objc_release
-  // CHECK: call void @objc_release
-  // CHECK: call void @objc_release
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
+  // CHECK: call void @llvm.objc.release
+  // CHECK: call void @llvm.objc.release
+  // CHECK: call void @llvm.objc.release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: ret void
 }
 
 @interface A
 @end
 
 @interface B
 @property (retain) A* prop;
 @end
 
 // CHECK-LABEL: define void @test_property
 void test_property(B *b) {
   // Retain parameter
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
 
   // CHECK:      [[T0:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[OBJECTS:%.*]], i64 0, i64 0
 
   // Invoke 'prop'
   // CHECK:      [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
   // CHECK-NEXT: [[T1:%.*]] = bitcast
   // CHECK-NEXT: [[T2:%.*]] = call [[B:%.*]]* bitcast ({{.*}} @objc_msgSend to {{.*}})(i8* [[T1]], i8* [[SEL]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast [[B]]* [[T2]] to i8*
-  // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T3]])
+  // CHECK-NEXT: [[T4:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T3]])
   // CHECK-NEXT: [[V0:%.*]] = bitcast i8* [[T4]] to [[B]]*
   // CHECK-NEXT: [[V1:%.*]] = bitcast [[B]]* [[V0]] to i8*
 
   // Store to array.
   // CHECK-NEXT: store i8* [[V1]], i8** [[T0]]
 
   // Invoke arrayWithObjects:count:
   // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T]]*, [[CLASS_T]]** @"OBJC_CLASSLIST
   // CHECK-NEXT: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8*
   // CHECK-NEXT: [[T2:%.*]] = bitcast [1 x i8*]* [[OBJECTS]] to i8**
   // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast ({{.*}} @objc_msgSend to {{.*}}(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i64 1)
-  // CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue(i8* [[T3]])
+  // CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T3]])
   // CHECK-NEXT: call void (...) @clang.arc.use(i8* [[V1]])
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: store
   id arr = @[ b.prop ];
 
   // Release b.prop
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[B]]* [[V0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
 
   // Destroy arr
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
 
   // Destroy b
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: ret void
 }

test/CodeGenObjC/arc-loadweakretained-release.m

@autoreleasepool {
 
         [weakRef foo];
 
         objPtr1 = (void *)0;
         return 0;
     }
 }
 
-// CHECK: [[SIXTEEN:%.*]]  = call i8* @objc_loadWeakRetained(i8** {{%.*}})
+// CHECK: [[SIXTEEN:%.*]]  = call i8* @llvm.objc.loadWeakRetained(i8** {{%.*}})
 // CHECK-NEXT:  [[SEVENTEEN:%.*]] = bitcast i8* [[SIXTEEN]] to {{%.*}}
 // CHECK-NEXT:  [[EIGHTEEN:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.6
 // CHECK-NEXT:  [[NINETEEN:%.*]] = bitcast %0* [[SEVENTEEN]] to i8*
 // CHECK-NEXT:  call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 // CHECK-NEXT:  [[TWENTY:%.*]] = bitcast %0* [[SEVENTEEN]] to i8*
-// CHECK-NEXT:  call void @objc_release(i8* [[TWENTY]])
+// CHECK-NEXT:  call void @llvm.objc.release(i8* [[TWENTY]])
 
 void test1(int cond) {
   extern void test34_sink(id *);
   __weak id weak;
   test34_sink(cond ? &weak : 0);
 }
 
 // CHECK-LABEL: define void @test1(
 // CHECK: [[CONDADDR:%.*]] = alloca i32
 // CHECK-NEXT: [[WEAK:%.*]] = alloca i8*
 // CHECK-NEXT: [[INCRTEMP:%.*]] = alloca i8*
 // CHECK-NEXT: [[CONDCLEANUPSAVE:%.*]] = alloca i8*
 // CHECK-NEXT: [[CONDCLEANUP:%.*]] = alloca i1
 // CHECK-NEXT: store i32
 // CHECK-NEXT: store i8* null, i8** [[WEAK]]
 // CHECK:  [[COND1:%.*]] = phi i8**
 // CHECK-NEXT: [[ICRISNULL:%.*]] = icmp eq i8** [[COND1]], null
 // CHECK-NEXT: [[ICRARGUMENT:%.*]] = select i1 [[ICRISNULL]], i8** null, i8** [[INCRTEMP]]
 // CHECK-NEXT: store i1 false, i1* [[CONDCLEANUP]]
 // CHECK-NEXT: br i1 [[ICRISNULL]], label [[ICRCONT:%.*]], label [[ICRCOPY:%.*]]
-// CHECK:  [[ONE:%.*]] = call i8* @objc_loadWeakRetained(
+// CHECK:  [[ONE:%.*]] = call i8* @llvm.objc.loadWeakRetained(
 // CHECK-NEXT: store i8* [[ONE]], i8** [[CONDCLEANUPSAVE]]
 // CHECK-NEXT: store i1 true, i1* [[CONDCLEANUP]]
 // CHECK-NEXT: store i8* [[ONE]], i8** [[INCRTEMP]]
 // CHECK-NEXT: br label
 
 // CHECK: call void @test34_sink(
 // CHECK-NEXT: [[ICRISNULL1:%.*]] = icmp eq i8** [[COND1]], null
 // CHECK-NEXT: br i1 [[ICRISNULL1]], label [[ICRDONE:%.*]], label [[ICRWRITEBACK:%.*]]
 // CHECK:  [[TWO:%.*]] = load i8*, i8** [[INCRTEMP]]
-// CHECK-NEXT:  [[THREE:%.*]] = call i8* @objc_storeWeak(
+// CHECK-NEXT:  [[THREE:%.*]] = call i8* @llvm.objc.storeWeak(
 // CHECK-NEXT:  br label [[ICRDONE]]
 // CHECK:  [[CLEANUPISACTIVE:%.*]] = load i1, i1* [[CONDCLEANUP]]
 // CHECK-NEXT:  br i1 [[CLEANUPISACTIVE]], label [[CLEASNUPACTION:%.*]], label [[CLEANUPDONE:%.*]]
 
 // CHECK: [[FOUR:%.*]] = load i8*, i8** [[CONDCLEANUPSAVE]]
-// CHECK-NEXT: call void @objc_release(i8* [[FOUR]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[FOUR]])
 // CHECK-NEXT:  br label
-// CHECK:  call void @objc_destroyWeak(i8** [[WEAK]])
+// CHECK:  call void @llvm.objc.destroyWeak(i8** [[WEAK]])
 // CHECK-NEXT: ret void

test/CodeGenObjC/arc-no-runtime.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-arc -emit-llvm %s -o - | FileCheck %s
 
 // rdar://problem/9224855
 id make(void) __attribute__((ns_returns_retained));
 void test0() {
   make();
   id x = 0;
-  // CHECK: call void @objc_release(
-  // CHECK: call void @objc_storeStrong(
+  // CHECK: call void @llvm.objc.release(
+  // CHECK: call void @llvm.objc.storeStrong(
 }
 
-// CHECK: declare extern_weak void @objc_release(
-// CHECK: declare extern_weak void @objc_storeStrong(
+// CHECK: declare extern_weak void @llvm.objc.release(
+// CHECK: declare extern_weak void @llvm.objc.storeStrong(

test/CodeGenObjC/arc-precise-lifetime.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -o - %s | FileCheck %s
 
 #define PRECISE_LIFETIME __attribute__((objc_precise_lifetime))
 
 id test0_helper(void) __attribute__((ns_returns_retained));
 void test0() {
   PRECISE_LIFETIME id x = test0_helper();
   x = 0;
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test0_helper()
   // CHECK-NEXT: store i8* [[CALL]], i8** [[X]]
 
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
   // CHECK-NEXT: store i8* null, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW:#[0-9]+]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW:#[0-9]+]]
   // CHECK-NOT:  clang.imprecise_release
 
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW:#[0-9]+]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW:#[0-9]+]]
   // CHECK-NOT:  clang.imprecise_release
 
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // rdar://problem/9821110 - precise lifetime should suppress extension
 // rdar://problem/22172983 - should work for calls via property syntax, too
 @interface Test1
 - (char*) interior __attribute__((objc_returns_inner_pointer));
 // Should we allow this on properties? Yes! see // rdar://14990439
 @property (nonatomic, readonly) char * PropertyReturnsInnerPointer __attribute__((objc_returns_inner_pointer));
 @end
 extern Test1 *test1_helper(void);
 
 // CHECK-LABEL: define void @test1a_message()
 void test1a_message(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[C:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
   // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
   // CHECK-NEXT: store i8* [[T6]], i8**
   // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   Test1 *ptr = test1_helper();
   char *c = [(ptr) interior];
 }
 
 
 // CHECK-LABEL: define void @test1a_property()
 void test1a_property(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[C:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
   // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
   // CHECK-NEXT: store i8* [[T6]], i8**
   // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   Test1 *ptr = test1_helper();
   char *c = ptr.interior;
 }
 
 
 // CHECK-LABEL: define void @test1b_message()
 void test1b_message(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[C:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
   // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast
   // CHECK-NEXT: store i8* [[T3]], i8**
   // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]]
   // CHECK-NOT:  clang.imprecise_release
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   PRECISE_LIFETIME Test1 *ptr = test1_helper();
   char *c = [ptr interior];
 }
 
 // CHECK-LABEL: define void @test1b_property()
 void test1b_property(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[C:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
   // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast
   // CHECK-NEXT: store i8* [[T3]], i8**
   // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]]
   // CHECK-NOT:  clang.imprecise_release
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   PRECISE_LIFETIME Test1 *ptr = test1_helper();
   char *c = ptr.interior;
 }
 
 // CHECK-LABEL: define void @test1c_message()
 void test1c_message(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[PC:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
   // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
   // CHECK-NEXT: store i8* [[T6]], i8**
   // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   Test1 *ptr = test1_helper();
   char *pc = [ptr PropertyReturnsInnerPointer];
 }
 
 // CHECK-LABEL: define void @test1c_property()
 void test1c_property(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[PC:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
   // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
   // CHECK-NEXT: store i8* [[T6]], i8**
   // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   Test1 *ptr = test1_helper();
   char *pc = ptr.PropertyReturnsInnerPointer;
 }
 
 // CHECK-LABEL: define void @test1d_message()
 void test1d_message(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[PC:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[SEVEN:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[EIGHT:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
   // CHECK-NEXT: [[CALL1:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* [[EIGHT]], i8* [[SEVEN]])
   // CHECK-NEXT: store i8* [[CALL1]], i8**
   // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
   // CHECK-NEXT: [[NINE:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[TEN:%.*]] = bitcast [[TEST1]]* [[NINE]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[TEN]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TEN]])
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   PRECISE_LIFETIME Test1 *ptr = test1_helper();
   char *pc = [ptr PropertyReturnsInnerPointer];
 }
 
 // CHECK-LABEL: define void @test1d_property()
 void test1d_property(void) {
   // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
   // CHECK:      [[PC:%.*]] = alloca i8*, align 8
   // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
   // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
   // CHECK-NEXT: store [[TEST1]]* [[T3]]
   // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[SEVEN:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[EIGHT:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
   // CHECK-NEXT: [[CALL1:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* [[EIGHT]], i8* [[SEVEN]])
   // CHECK-NEXT: store i8* [[CALL1]], i8**
   // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
   // CHECK-NEXT: [[NINE:%.*]] = load [[TEST1]]*, [[TEST1]]**
   // CHECK-NEXT: [[TEN:%.*]] = bitcast [[TEST1]]* [[NINE]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[TEN]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TEN]])
   // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
   // CHECK-NEXT: ret void
   PRECISE_LIFETIME Test1 *ptr = test1_helper();
   char *pc = ptr.PropertyReturnsInnerPointer;
 }
 
 @interface Test2 {
 @public
   id ivar;
 }
 @end
 // CHECK-LABEL:      define void @test2(
 void test2(Test2 *x) {
   x->ivar = 0;
   // CHECK:      [[X:%.*]] = alloca [[TEST2:%.*]]*
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST2]]* {{%.*}} to i8*
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]]) [[NUW]]
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) [[NUW]]
   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to [[TEST2]]*
   // CHECK-NEXT: store [[TEST2]]* [[T2]], [[TEST2]]** [[X]],
 
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST2]]*, [[TEST2]]** [[X]],
   // CHECK-NEXT: [[OFFSET:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test2.ivar"
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST2]]* [[T0]] to i8*
   // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8, i8* [[T1]], i64 [[OFFSET]]
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8**
   // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** [[T3]],
   // CHECK-NEXT: store i8* null, i8** [[T3]],
-  // CHECK-NEXT: call void @objc_release(i8* [[T4]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T4]]) [[NUW]]
   // CHECK-NOT:  imprecise
 
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST2]]*, [[TEST2]]** [[X]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST2]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
 
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL:      define void @test3(i8*
 void test3(PRECISE_LIFETIME id x) {
   // CHECK:      [[X:%.*]] = alloca i8*,
-  // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* {{%.*}}) [[NUW]]
+  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}}) [[NUW]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[X]],
 
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]]
   // CHECK-NOT:  imprecise_release
 
   // CHECK-NEXT: ret void  
 }
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/arc-property.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-arc -emit-llvm %s -o - | FileCheck %s
 
 // rdar://problem/10290317
 @interface Test0
 - (void) setValue: (id) x;
 @end
 void test0(Test0 *t0, id value) {
   t0.value = value;
 }
 // CHECK-LABEL: define void @test0(
-// CHECK: call void @objc_storeStrong
-// CHECK: call void @objc_storeStrong
+// CHECK: call void @llvm.objc.storeStrong
+// CHECK: call void @llvm.objc.storeStrong
 // CHECK: @objc_msgSend
-// CHECK: call void @objc_storeStrong(
-// CHECK: call void @objc_storeStrong(
+// CHECK: call void @llvm.objc.storeStrong(
+// CHECK: call void @llvm.objc.storeStrong(
 
 struct S1 { Class isa; };
 @interface Test1
 @property (nonatomic, strong) __attribute__((NSObject)) struct S1 *pointer;
 @end
 @implementation Test1
 @synthesize pointer;
 @end

 @end
 // CHECK:    define internal void @"\01-[Test2 test]"(
 // CHECK:      [[T0:%.*]] = load i8*, i8** @theGlobalClass, align 8
 // CHECK-NEXT: [[T1:%.*]] = load [[TEST2:%.*]]*, [[TEST2:%.*]]**
 // CHECK-NEXT: [[OFFSET:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test2._theClass"
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST2]]* [[T1]] to i8*
 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds i8, i8* [[T2]], i64 [[OFFSET]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T4]], i8* [[T0]]) [[NUW:#[0-9]+]]
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T4]], i8* [[T0]]) [[NUW:#[0-9]+]]
 // CHECK-NEXT: ret void
 
 // CHECK:    define internal i8* @"\01-[Test2 theClass]"(
 // CHECK:      [[OFFSET:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test2._theClass"
 // CHECK-NEXT: [[T0:%.*]] = tail call i8* @objc_getProperty(i8* {{.*}}, i8* {{.*}}, i64 [[OFFSET]], i1 zeroext true)
 // CHECK-NEXT: ret i8* [[T0]]
 
 // CHECK:    define internal void @"\01-[Test2 setTheClass:]"(
 // CHECK:      [[T0:%.*]] = bitcast [[TEST2]]* {{%.*}} to i8*
 // CHECK-NEXT: [[OFFSET:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test2._theClass"
 // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** {{%.*}}
 // CHECK-NEXT: call void @objc_setProperty(i8* [[T0]], i8* {{%.*}}, i64 [[OFFSET]], i8* [[T1]], i1 zeroext true, i1 zeroext true)
 // CHECK-NEXT: ret void
 
 // CHECK:    define internal void @"\01-[Test2 .cxx_destruct]"(
 // CHECK:      [[T0:%.*]] = load [[TEST2]]*, [[TEST2]]**
 // CHECK-NEXT: [[OFFSET:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test2._theClass"
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST2]]* [[T0]] to i8*
 // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8, i8* [[T1]], i64 [[OFFSET]]
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T3]], i8* null) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T3]], i8* null) [[NUW]]
 // CHECK-NEXT: ret void
 
 // rdar://13115896
 @interface Test3
 @property id copyMachine;
 @end
 
 void test3(Test3 *t) {

 // CHECK-NEXT: store i8* [[T2]], i8** [[X]],
 //   Message send.
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST3]]*, [[TEST3]]** [[T]],
 // CHECK-NEXT: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8*
 // CHECK-NEXT: [[T2:%.*]] = call i8* bitcast ({{.*}} @objc_msgSend to {{.*}})(i8* [[T1]], i8* [[SEL]])
 // CHECK-NEXT: [[T3:%.*]] = load i8*, i8** [[X]],
 // CHECK-NEXT: store i8* [[T2]], i8** [[X]],
-// CHECK-NEXT: call void @objc_release(i8* [[T3]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T3]])
 //   Epilogue.
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[X]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* null)
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST3]]** [[T]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK-NEXT: ret void
 
 @implementation Test3
 - (id) copyMachine {
   extern id test3_helper(void);
   return test3_helper();
 }
 // CHECK:    define internal i8* @"\01-[Test3 copyMachine]"(
 // CHECK:      [[T0:%.*]] = call i8* @test3_helper()
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
 // CHECK-NEXT: ret i8* [[T1]]
 - (void) setCopyMachine: (id) x {}
 @end
 
 // rdar://31579994
 // When synthesizing a property that's declared in multiple protocols, ensure
 // that the setter is emitted if any of these declarations is readwrite.
 @protocol ABC

test/CodeGenObjC/arc-related-result-type.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s
 
 @interface Test0
 - (id) self;
 @end
 void test0(Test0 *val) {
   Test0 *x = [val self];
 
 // CHECK-LABEL:    define void @test0(
 // CHECK:      [[VAL:%.*]] = alloca [[TEST0:%.*]]*
 // CHECK-NEXT: [[X:%.*]] = alloca [[TEST0]]*
 // CHECK-NEXT: store [[TEST0]]* null
 // CHECK-NEXT: bitcast
 // CHECK-NEXT: bitcast
-// CHECK-NEXT: call void @objc_storeStrong(
+// CHECK-NEXT: call void @llvm.objc.storeStrong(
 // CHECK-NEXT: load [[TEST0]]*, [[TEST0]]** [[VAL]],
 // CHECK-NEXT: load
 // CHECK-NEXT: bitcast
 // CHECK-NEXT: [[T0:%.*]] = call i8* bitcast (
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to [[TEST0]]*
 // CHECK-NEXT: store [[TEST0]]* [[T2]], [[TEST0]]** [[X]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST0]]** [[X]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST0]]** [[VAL]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK-NEXT: ret void
 }

test/CodeGenObjC/arc-ternary-op.m

void test0(_Bool cond) {
   // CHECK-NEXT: store i1 false, i1* [[RELCOND]]
   // CHECK-NEXT: br i1 [[T1]],
   // CHECK:      br label
   // CHECK:      [[CALL:%.*]] = call i8* @test0_helper()
   // CHECK-NEXT: store i8* [[CALL]], i8** [[RELVAL]]
   // CHECK-NEXT: store i1 true, i1* [[RELCOND]]
   // CHECK-NEXT: br label
   // CHECK:      [[T0:%.*]] = phi i8* [ null, {{%.*}} ], [ [[CALL]], {{%.*}} ]
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]]) [[NUW:#[0-9]+]]
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) [[NUW:#[0-9]+]]
   // CHECK-NEXT: store i8* [[T1]], i8** [[X]],
   // CHECK-NEXT: [[REL:%.*]] = load i1, i1* [[RELCOND]]
   // CHECK-NEXT: br i1 [[REL]],
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[RELVAL]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]]
   // CHECK-NEXT: br label
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]]
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
   id x = (cond ? 0 : test0_helper());
 }
 
 void test1(int cond) {
   __strong id strong;
void test1(int cond) {
   // CHECK-NEXT: [[CONDCLEANUPSAVE:%.*]] = alloca i8*
   // CHECK-NEXT: [[CONDCLEANUP:%.*]] = alloca i1
   // CHECK-NEXT: store i32
   // CHECK-NEXT: [[STRONGPTR1:%.*]] = bitcast i8** [[STRONG]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[STRONGPTR1]])
   // CHECK-NEXT: store i8* null, i8** [[STRONG]]
   // CHECK-NEXT: [[WEAKPTR1:%.*]] = bitcast i8** [[WEAK]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[WEAKPTR1]])
-  // CHECK-NEXT: call i8* @objc_initWeak(i8** [[WEAK]], i8* null)
+  // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[WEAK]], i8* null)
 
   // CHECK-NEXT: [[T0:%.*]] = load i32, i32* [[COND]]
   // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
   // CHECK:      [[ARG:%.*]] = phi i8**
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP1]]
   // CHECK-NEXT: br i1 [[T0]],
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[ARG]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP1]]
   // CHECK-NEXT: br label
   // CHECK:      [[W:%.*]] = phi i8* [ [[T0]], {{%.*}} ], [ undef, {{%.*}} ]
   // CHECK-NEXT: call void @test1_sink(i8** [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: br i1 [[T0]],
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[TEMP1]]
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   // CHECK-NEXT: call void (...) @clang.arc.use(i8* [[W]]) [[NUW]]
   // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[ARG]]
   // CHECK-NEXT: store i8* [[T1]], i8** [[ARG]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T2]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
   // CHECK-NEXT: br label
 
   // CHECK:      [[T0:%.*]] = load i32, i32* [[COND]]
   // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
   // CHECK:      [[ARG:%.*]] = phi i8**
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP2]]
   // CHECK-NEXT: store i1 false, i1* [[CONDCLEANUP]]
   // CHECK-NEXT: br i1 [[T0]],
-  // CHECK:      [[T0:%.*]] = call i8* @objc_loadWeakRetained(i8** [[ARG]])
+  // CHECK:      [[T0:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[ARG]])
   // CHECK-NEXT: store i8* [[T0]], i8** [[CONDCLEANUPSAVE]]
   // CHECK-NEXT: store i1 true, i1* [[CONDCLEANUP]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP2]]
   // CHECK-NEXT: br label
   // CHECK:      call void @test1_sink(i8** [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: br i1 [[T0]],
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[TEMP2]]
-  // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[ARG]], i8* [[T0]])
+  // CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[ARG]], i8* [[T0]])
   // CHECK-NEXT: br label
 
-  // CHECK:      call void @objc_destroyWeak(i8** [[WEAK]])
+  // CHECK:      call void @llvm.objc.destroyWeak(i8** [[WEAK]])
   // CHECK:      [[WEAKPTR2:%.*]] = bitcast i8** [[WEAK]] to i8*
   // CHECK:      call void @llvm.lifetime.end.p0i8(i64 8, i8* [[WEAKPTR2]])
   // CHECK:      [[STRONGPTR2:%.*]] = bitcast i8** [[STRONG]] to i8*
   // CHECK:      call void @llvm.lifetime.end.p0i8(i64 8, i8* [[STRONGPTR2]])
   // CHECK:      ret void
 }
 
 // rdar://13113981
void test2(int cond) {
   // CHECK:      [[RUN_CLEANUP:%.*]] = alloca i1
   //   Evaluate condition; cleanup disabled by default.
   // CHECK:      [[T0:%.*]] = load i32, i32* [[COND]],
   // CHECK-NEXT: icmp ne i32 [[T0]], 0
   // CHECK-NEXT: store i1 false, i1* [[RUN_CLEANUP]]
   // CHECK-NEXT: br i1
   //   Within true branch, cleanup enabled.
   // CHECK:      [[T0:%.*]] = call i8* @test2_producer()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T1]], i8** [[CLEANUP_SAVE]]
   // CHECK-NEXT: store i1 true, i1* [[RUN_CLEANUP]]
   // CHECK-NEXT: br label
   //   Join point for conditional operator; retain immediately.
   // CHECK:      [[T0:%.*]] = phi i8* [ [[T1]], {{%.*}} ], [ null, {{%.*}} ]
-  // CHECK-NEXT: [[RESULT:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: [[RESULT:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   //   Leaving full-expression; run conditional cleanup.
   // CHECK-NEXT: [[T0:%.*]] = load i1, i1* [[RUN_CLEANUP]]
   // CHECK-NEXT: br i1 [[T0]]
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[CLEANUP_SAVE]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: br label
   //   And way down at the end of the loop:
-  // CHECK:      call void @objc_release(i8* [[RESULT]])
+  // CHECK:      call void @llvm.objc.release(i8* [[RESULT]])
 }
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/arc-unbridged-cast.m

 // rdar://9544832
 CFStringRef SomeOtherFunc() __attribute__((cf_returns_retained));
 id MMM()
 {
   id obj = (id)((CFStringRef) __builtin___CFStringMakeConstantString ("" "Some CF String" ""));
   return 0;
 }
 
-// CHECK-NOT: call i8* @objc_retainAutoreleasedReturnValue
+// CHECK-NOT: call i8* @llvm.objc.retainAutoreleasedReturnValue

test/CodeGenObjC/arc-unopt.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -o - %s | FileCheck %s
 
 // A test to ensure that we generate fused calls at -O0.
 
 @class Test0;
 Test0 *test0(void) {
   extern Test0 *test0_helper;
   return test0_helper;
 
   // CHECK:      [[LD:%.*]] = load [[TEST0:%.*]]*, [[TEST0:%.*]]** @test0_helper
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST0]]* [[LD]] to i8*
-  // CHECK-NEXT: [[T1:%.*]] = tail call i8* @objc_retainAutoreleaseReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = tail call i8* @llvm.objc.retainAutoreleaseReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to [[TEST0]]*
   // CHECK-NEXT: ret [[TEST0]]* [[T2]]
 }
 
 id test1(void) {
   extern id test1_helper;
   return test1_helper;
 
   // CHECK:      [[LD:%.*]] = load i8*, i8** @test1_helper
-  // CHECK-NEXT: [[T0:%.*]] = tail call i8* @objc_retainAutoreleaseReturnValue(i8* [[LD]])
+  // CHECK-NEXT: [[T0:%.*]] = tail call i8* @llvm.objc.retainAutoreleaseReturnValue(i8* [[LD]])
   // CHECK-NEXT: ret i8* [[T0]]
 }
 
 void test2(void) {
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: store i8* null, i8** [[X]]
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** [[X]])
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[X]])
   // CHECK-NEXT: ret void
   __weak id x;
 }
 
 id test3(void) {
   extern id test3_helper(void);
   // CHECK:      [[T0:%.*]] = call i8* @test3_helper()
   // CHECK-NEXT: ret i8* [[T0]]

 // CHECK-LABEL:    define void @test5()
 // CHECK:      [[X:%.*]] = alloca [[TEST5:%.*]]*,
 // CHECK-NEXT: [[Y:%.*]] = alloca [[TEST5:%.*]]*,
 // CHECK-NEXT: store [[TEST5]]* null, [[TEST5]]** [[X]],
 // CHECK-NEXT: store [[TEST5]]* null, [[TEST5]]** [[Y]],
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST5]]*, [[TEST5]]** [[Y]],
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST5]]** [[X]] to i8**
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST5]]* [[T0]] to i8*
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T1]], i8* [[T2]])
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T1]], i8* [[T2]])
 // CHECK-NEXT: [[T3:%.*]] = icmp ne [[TEST5]]* [[T0]], null
 // CHECK-NEXT: br i1 [[T3]],
 }

test/CodeGenObjC/arc-unoptimized-byref-var.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -o - %s | FileCheck -check-prefix=CHECK-UNOPT %s
 // rdar://12530881
 
 void test19() {
    __block id x;
    ^{ (void)x; };
 // CHECK-UNOPT-LABEL: define internal void @__Block_byref_object_copy
 // CHECK-UNOPT: [[X:%.*]] = getelementptr inbounds [[BYREF_T:%.*]], [[BYREF_T:%.*]]* [[VAR:%.*]], i32 0, i32 6
 // CHECK-UNOPT: [[X2:%.*]] = getelementptr inbounds [[BYREF_T:%.*]], [[BYREF_T:%.*]]* [[VAR1:%.*]], i32 0, i32 6
 // CHECK-UNOPT-NEXT: [[SIX:%.*]] = load i8*, i8** [[X2]], align 8
 // CHECK-UNOPT-NEXT: store i8* null, i8** [[X]], align 8
-// CHECK-UNOPT-NEXT: call void @objc_storeStrong(i8** [[X]], i8* [[SIX]]) [[NUW:#[0-9]+]]
-// CHECK-UNOPT-NEXT: call void @objc_storeStrong(i8** [[X2]], i8* null) [[NUW]]
+// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* [[SIX]]) [[NUW:#[0-9]+]]
+// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[X2]], i8* null) [[NUW]]
 // CHECK-UNOPT-NEXT: ret void
 }
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/arc-unsafeclaim.m

void test_assign() {
   __unsafe_unretained id x;
   x = makeA();
 }
 // CHECK-LABEL:        define void @test_assign()
 // CHECK:                [[X:%.*]] = alloca i8*
 // CHECK:                [[T0:%.*]] = call [[A:.*]]* @makeA()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
 // CHECK-NEXT:           ret void
 
 // DISABLED-LABEL:     define void @test_assign()
 // DISABLED:             [[T0:%.*]] = call [[A:.*]]* @makeA()
 // DISABLED-MARKED-NEXT: call void asm sideeffect
 // DISABLED-NEXT:        [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// DISABLED-NEXT:        [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// DISABLED-NEXT:        [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 
 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()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           store i8* [[T4]], i8** [[Y]]
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-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()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           store i8* [[T4]], i8** [[Y]]
 // CHECK-NEXT:           [[OLD:%.*]] = load i8*, i8** [[X]]
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
-// CHECK-NEXT:           call void @objc_release(i8* [[OLD]]
+// CHECK-NEXT:           call void @llvm.objc.release(i8* [[OLD]]
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
-// CHECK-UNOPTIMIZED-NEXT: call void @objc_storeStrong(i8** [[X]], i8* null)
+// CHECK-UNOPTIMIZED-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* null)
 // CHECK-OPTIMIZED-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-// CHECK-OPTIMIZED-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-OPTIMIZED-NEXT: call void @llvm.objc.release(i8* [[T0]])
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-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()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           [[OLD:%.*]] = load i8*, i8** [[Y]]
 // CHECK-NEXT:           store i8* [[T4]], i8** [[Y]]
-// CHECK-NEXT:           call void @objc_release(i8* [[OLD]]
+// CHECK-NEXT:           call void @llvm.objc.release(i8* [[OLD]]
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
-// CHECK-UNOPTIMIZED-NEXT: call void @objc_storeStrong(i8** [[Y]], i8* null)
+// CHECK-UNOPTIMIZED-NEXT: call void @llvm.objc.storeStrong(i8** [[Y]], i8* null)
 // CHECK-OPTIMIZED-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-// CHECK-OPTIMIZED-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-OPTIMIZED-NEXT: call void @llvm.objc.release(i8* [[T0]])
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-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()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-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()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
 // CHECK-NEXT:           store i8* [[T4]], i8** [[Y]]
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-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()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
 // CHECK-NEXT:           store i8* [[T4]], i8** [[Y]]
-// CHECK-UNOPTIMIZED-NEXT: call void @objc_storeStrong(i8** [[Y]], i8* null)
+// CHECK-UNOPTIMIZED-NEXT: call void @llvm.objc.storeStrong(i8** [[Y]], i8* null)
 // CHECK-OPTIMIZED-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-// CHECK-OPTIMIZED-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-OPTIMIZED-NEXT: call void @llvm.objc.release(i8* [[T0]])
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-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()
 // CHECK-MARKED-NEXT:    call void asm sideeffect
 // CHECK-NEXT:           [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:           [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:           [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:           [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:           [[T4:%.*]] = bitcast [[A]]* [[T3]] to i8*
 // CHECK-NEXT:           [[OLD:%.*]] = load i8*, i8** [[X]]
 // CHECK-NEXT:           store i8* [[T4]], i8** [[X]]
-// CHECK-NEXT:           call void @objc_release(i8* [[OLD]])
+// CHECK-NEXT:           call void @llvm.objc.release(i8* [[OLD]])
 // CHECK-NEXT:           store i8* [[T4]], i8** [[Y]]
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
-// CHECK-UNOPTIMIZED-NEXT: call void @objc_storeStrong(i8** [[X]], i8* null)
+// CHECK-UNOPTIMIZED-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* null)
 // CHECK-OPTIMIZED-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-// CHECK-OPTIMIZED-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-OPTIMIZED-NEXT: call void @llvm.objc.release(i8* [[T0]])
 // CHECK-OPTIMIZED-NEXT: bitcast
 // CHECK-OPTIMIZED-NEXT: lifetime.end
 // CHECK-NEXT: ret void
 
 void test_ignored() {
   makeA();
 }
 // CHECK-LABEL:     define void @test_ignored()
 // CHECK:             [[T0:%.*]] = call [[A]]* @makeA()
 // CHECK-MARKED-NEXT: call void asm sideeffect
 // CHECK-NEXT:        [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:        [[T2:%.*]] = call i8* @objc_unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:        [[T2:%.*]] = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:        bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:        ret void
 
 void test_cast_to_void() {
   (void) makeA();
 }
 // CHECK-LABEL:     define void @test_cast_to_void()
 // CHECK:             [[T0:%.*]] = call [[A]]* @makeA()
 // CHECK-MARKED-NEXT: call void asm sideeffect
 // CHECK-NEXT:        [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK-NEXT:        [[T2:%.*]] = call i8* @objc_unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT:        [[T2:%.*]] = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT:        bitcast i8* [[T2]] to [[A]]*
 // CHECK-NEXT:        ret void
 
 
 
 // This is always at the end of the module.
 
 // CHECK-OPTIMIZED: !clang.arc.retainAutoreleasedReturnValueMarker = !{!0}

test/CodeGenObjC/arc-weak-property.m

 // CHECK-NEXT:  [[CMD:%.*]] = alloca i8*,
 // CHECK-NEXT:  store [[WPT]]* {{%.*}}, [[WPT]]** [[SELF]]
 // CHECK-NEXT:  store i8* {{%.*}}, i8** [[CMD]]
 // CHECK-NEXT:  [[T0:%.*]] = load [[WPT]]*, [[WPT]]** [[SELF]]
 // CHECK-NEXT:  [[T1:%.*]] = load i64, i64* @"OBJC_IVAR_$_WeakPropertyTest.PROP"
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[WPT]]* [[T0]] to i8*
 // CHECK-NEXT:  [[T3:%.*]] = getelementptr inbounds i8, i8* [[T2]], i64 [[T1]]
 // CHECK-NEXT:  [[T4:%.*]] = bitcast i8* [[T3]] to i8**
-// CHECK-NEXT:  [[T5:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T4]])
-// CHECK-NEXT:  [[T6:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[T5]])
+// CHECK-NEXT:  [[T5:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T4]])
+// CHECK-NEXT:  [[T6:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T5]])
 // CHECK-NEXT:  ret i8* [[T6]]
 
 // CHECK:     define internal void @"\01-[WeakPropertyTest setPROP:]"
 // CHECK:       [[SELF:%.*]] = alloca [[WPT:%.*]]*,
 // CHECK-NEXT:  [[CMD:%.*]] = alloca i8*,
 // CHECK-NEXT:  [[PROP:%.*]] = alloca i8*,
 // CHECK-NEXT:  store [[WPT]]* {{%.*}}, [[WPT]]** [[SELF]]
 // CHECK-NEXT:  store i8* {{%.*}}, i8** [[CMD]]
 // CHECK-NEXT:  store i8* {{%.*}}, i8** [[PROP]]
 // CHECK-NEXT:  [[V:%.*]] = load i8*, i8** [[PROP]]
 // CHECK-NEXT:  [[T0:%.*]] = load [[WPT]]*, [[WPT]]** [[SELF]]
 // CHECK-NEXT:  [[T1:%.*]] = load i64, i64* @"OBJC_IVAR_$_WeakPropertyTest.PROP"
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[WPT]]* [[T0]] to i8*
 // CHECK-NEXT:  [[T3:%.*]] = getelementptr inbounds i8, i8* [[T2]], i64 [[T1]]
 // CHECK-NEXT:  [[T4:%.*]] = bitcast i8* [[T3]] to i8**
-// CHECK-NEXT:  call i8* @objc_storeWeak(i8** [[T4]], i8* [[V]])
+// CHECK-NEXT:  call i8* @llvm.objc.storeWeak(i8** [[T4]], i8* [[V]])
 // CHECK-NEXT:  ret void
 
 // CHECK:     define internal void @"\01-[WeakPropertyTest .cxx_destruct]"
 // CHECK:       [[SELF:%.*]] = alloca [[WPT:%.*]]*,
 // CHECK-NEXT:  [[CMD:%.*]] = alloca i8*,
 // CHECK-NEXT:  store [[WPT]]* {{%.*}}, [[WPT]]** [[SELF]]
 // CHECK-NEXT:  store i8* {{%.*}}, i8** [[CMD]]
 // CHECK-NEXT:  [[T0:%.*]] = load [[WPT]]*, [[WPT]]** [[SELF]]
 // CHECK-NEXT:  [[T1:%.*]] = load i64, i64* @"OBJC_IVAR_$_WeakPropertyTest.PROP"
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[WPT]]* [[T0]] to i8*
 // CHECK-NEXT:  [[T3:%.*]] = getelementptr inbounds i8, i8* [[T2]], i64 [[T1]]
 // CHECK-NEXT:  [[T4:%.*]] = bitcast i8* [[T3]] to i8**
-// CHECK-NEXT:  call void @objc_destroyWeak(i8** [[T4]])
+// CHECK-NEXT:  call void @llvm.objc.destroyWeak(i8** [[T4]])
 // CHECK-NEXT:  ret void

test/CodeGenObjC/arc-weak.m

 }
 // CHECK-LABEL: define void @test0
 // CHECK:       [[SRC:%.*]] = alloca [[B:%.*]]**, align 8
 // CHECK:       [[DEST:%.*]] = alloca [[A:%.*]]*, align 8
 // CHECK:       [[T0:%.*]] = load [[B]]**, [[B]]*** [[SRC]], align 8
 // CHECK-NEXT:  [[T1:%.*]] = bitcast [[B]]** [[T0]] to [[A]]**
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[A]]** [[DEST]] to i8**
 // CHECK-NEXT:  [[T3:%.*]] = bitcast [[A]]** [[T1]] to i8**
-// CHECK-NEXT:  call void @objc_copyWeak(i8** [[T2]], i8** [[T3]])
+// CHECK-NEXT:  call void @llvm.objc.copyWeak(i8** [[T2]], i8** [[T3]])
 // CHECK-NEXT:  [[T0:%.*]] = bitcast [[A]]** [[DEST]] to i8**
-// CHECK:       call void @objc_destroyWeak(i8** [[T0]])
+// CHECK:       call void @llvm.objc.destroyWeak(i8** [[T0]])

test/CodeGenObjC/arc-with-atthrow.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -fobjc-exceptions -o - %s | FileCheck %s
 // pr10411
 // rdar://10042689
 
 id make(void);
 void test() { 
   @throw make();
 }
 
 // TODO: We should probably emit this specific pattern without the reclaim.
 
 // CHECK-LABEL:    define void @test()
 // CHECK:      [[T0:%.*]] = call i8* @make()
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_autorelease(i8* [[T1]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.autorelease(i8* [[T1]])
 // CHECK-NEXT: call void @objc_exception_throw(i8* [[T2]]) [[NR:#[0-9]+]]
 // CHECK-NEXT: unreachable
 
 // CHECK: attributes [[NR]] = { noreturn }

test/CodeGenObjC/arc.ll

 ; RUN: %clang_cc1 -Os -emit-llvm -fobjc-arc -o - %s | FileCheck %s
 
 target triple = "x86_64-apple-darwin10"
 
-declare i8* @objc_retain(i8*)
-declare void @objc_release(i8*)
+declare i8* @llvm.objc.retain(i8*)
+declare void @llvm.objc.release(i8*)
 
 ; CHECK-LABEL: define void @test(
 ; CHECK-NOT: @objc_
 ; CHECK: }
 define void @test(i8* %x, i1* %p) nounwind {
 entry:
   br label %loop
 
 loop:
-  call i8* @objc_retain(i8* %x)
+  call i8* @llvm.objc.retain(i8* %x)
   %q = load i1, i1* %p
   br i1 %q, label %loop.more, label %exit
 
 loop.more:
-  call void @objc_release(i8* %x)
+  call void @llvm.objc.release(i8* %x)
   br label %loop
 
 exit:
-  call void @objc_release(i8* %x)
+  call void @llvm.objc.release(i8* %x)
   ret void
 }

test/CodeGenObjC/arc.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -Wno-objc-root-class -Wno-incompatible-pointer-types -Wno-arc-unsafe-retained-assign -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -Wno-objc-root-class -Wno-incompatible-pointer-types -Wno-arc-unsafe-retained-assign -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -o - %s | FileCheck -check-prefix=CHECK-GLOBALS %s
 
 // rdar://13129783. Check both native/non-native arc platforms. Here we check
 // that they treat nonlazybind differently.
 // RUN: %clang_cc1 -fobjc-runtime=macosx-10.6.0 -triple x86_64-apple-darwin10 -Wno-objc-root-class -Wno-incompatible-pointer-types -Wno-arc-unsafe-retained-assign -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -o - %s | FileCheck -check-prefix=ARC-ALIEN %s
 // RUN: %clang_cc1 -fobjc-runtime=macosx-10.7.0 -triple x86_64-apple-darwin11 -Wno-objc-root-class -Wno-incompatible-pointer-types -Wno-arc-unsafe-retained-assign -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -o - %s | FileCheck -check-prefix=ARC-NATIVE %s
 
-// ARC-ALIEN: declare extern_weak void @objc_storeStrong(i8**, i8*)
-// ARC-ALIEN: declare extern_weak i8* @objc_retain(i8*)
-// ARC-ALIEN: declare extern_weak i8* @objc_autoreleaseReturnValue(i8*)
+// ARC-ALIEN: declare extern_weak void @llvm.objc.storeStrong(i8**, i8*)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.retain(i8*)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.autoreleaseReturnValue(i8*)
 // ARC-ALIEN: declare i8* @objc_msgSend(i8*, i8*, ...) [[NLB:#[0-9]+]]
-// ARC-ALIEN: declare extern_weak void @objc_release(i8*)
-// ARC-ALIEN: declare extern_weak i8* @objc_retainAutoreleasedReturnValue(i8*)
-// ARC-ALIEN: declare extern_weak i8* @objc_initWeak(i8**, i8*)
-// ARC-ALIEN: declare extern_weak i8* @objc_storeWeak(i8**, i8*)
-// ARC-ALIEN: declare extern_weak i8* @objc_loadWeakRetained(i8**)
-// ARC-ALIEN: declare extern_weak void @objc_destroyWeak(i8**)
-// ARC-ALIEN: declare extern_weak i8* @objc_autorelease(i8*)
-// ARC-ALIEN: declare extern_weak i8* @objc_retainAutorelease(i8*)
-
-// ARC-NATIVE: declare void @objc_storeStrong(i8**, i8*)
-// ARC-NATIVE: declare i8* @objc_retain(i8*) [[NLB:#[0-9]+]]
-// ARC-NATIVE: declare i8* @objc_autoreleaseReturnValue(i8*)
-// ARC-NATIVE: declare i8* @objc_msgSend(i8*, i8*, ...) [[NLB]]
-// ARC-NATIVE: declare void @objc_release(i8*) [[NLB]]
-// ARC-NATIVE: declare i8* @objc_retainAutoreleasedReturnValue(i8*)
-// ARC-NATIVE: declare i8* @objc_initWeak(i8**, i8*)
-// ARC-NATIVE: declare i8* @objc_storeWeak(i8**, i8*)
-// ARC-NATIVE: declare i8* @objc_loadWeakRetained(i8**)
-// ARC-NATIVE: declare void @objc_destroyWeak(i8**)
-// ARC-NATIVE: declare i8* @objc_autorelease(i8*)
-// ARC-NATIVE: declare i8* @objc_retainAutorelease(i8*)
+// ARC-ALIEN: declare extern_weak void @llvm.objc.release(i8*)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.initWeak(i8**, i8*)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.storeWeak(i8**, i8*)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.loadWeakRetained(i8**)
+// ARC-ALIEN: declare extern_weak void @llvm.objc.destroyWeak(i8**)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.autorelease(i8*)
+// ARC-ALIEN: declare extern_weak i8* @llvm.objc.retainAutorelease(i8*)
+
+// ARC-NATIVE: declare void @llvm.objc.storeStrong(i8**, i8*)
+// ARC-NATIVE: declare i8* @llvm.objc.retain(i8*)
+// ARC-NATIVE: declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
+// ARC-NATIVE: declare i8* @objc_msgSend(i8*, i8*, ...) [[NLB:#[0-9]+]]
+// ARC-NATIVE: declare void @llvm.objc.release(i8*)
+// ARC-NATIVE: declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
+// ARC-NATIVE: declare i8* @llvm.objc.initWeak(i8**, i8*)
+// ARC-NATIVE: declare i8* @llvm.objc.storeWeak(i8**, i8*)
+// ARC-NATIVE: declare i8* @llvm.objc.loadWeakRetained(i8**)
+// ARC-NATIVE: declare void @llvm.objc.destroyWeak(i8**)
+// ARC-NATIVE: declare i8* @llvm.objc.autorelease(i8*)
+// ARC-NATIVE: declare i8* @llvm.objc.retainAutorelease(i8*)
 
 // CHECK-LABEL: define void @test0
 void test0(id x) {
   // CHECK:      [[X:%.*]] = alloca i8*
-  // CHECK-NEXT: [[PARM:%.*]] = call i8* @objc_retain(i8* {{.*}})
+  // CHECK-NEXT: [[PARM:%.*]] = call i8* @llvm.objc.retain(i8* {{.*}})
   // CHECK-NEXT: store i8* [[PARM]], i8** [[X]]
   // CHECK-NEXT: [[TMP:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[TMP]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TMP]])
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define i8* @test1(i8*
 id test1(id x) {
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[Y:%.*]] = alloca i8*
-  // CHECK-NEXT: [[PARM:%.*]] = call i8* @objc_retain(i8* {{%.*}})
+  // CHECK-NEXT: [[PARM:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}})
   // CHECK-NEXT: store i8* [[PARM]], i8** [[X]]
   // CHECK-NEXT: [[YPTR1:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[YPTR1]])
   // CHECK-NEXT: store i8* null, i8** [[Y]]
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-  // CHECK-NEXT: [[RET:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: [[RET:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: [[YPTR2:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[YPTR2]])
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
-  // CHECK-NEXT: [[T1:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[RET]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
+  // CHECK-NEXT: [[T1:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[RET]])
   // CHECK-NEXT: ret i8* [[T1]]
   id y;
   return y;
 }
 
 @interface Test2
 + (void) class_method;
 - (void) inst_method;
void test3_unelided() {
 
   // Call to +alloc.
   // CHECK-NEXT: load {{.*}}, {{.*}}* @"OBJC_CLASSLIST_REFERENCES_
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: bitcast
-  // CHECK-NEXT: call void @objc_release(i8*
+  // CHECK-NEXT: call void @llvm.objc.release(i8*
   [Test3 alloc];
 
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST3]]*, [[TEST3]]** [[X]]
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8*
   // CHECK-NEXT: [[COPY:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend {{.*}})(i8* [[T1]],
-  // CHECK-NEXT: call void @objc_release(i8* [[COPY]]) [[NUW:#[0-9]+]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[COPY]]) [[NUW:#[0-9]+]]
   [x copy];
 
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST3]]*, [[TEST3]]** [[X]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]]
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast [[TEST3]]** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @test3()
 void test3() {
   // CHECK:      [[X:%.*]] = alloca i8*
void test3() {
   // Call to -copy.
   // CHECK-NEXT: [[V:%.*]] = load i8*, i8** [[X]]
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[COPY:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend {{.*}})(i8* [[V]],
 
   // Assignment to x.
   // CHECK-NEXT: [[TMP:%.*]] = load i8*, i8** [[X]]
   // CHECK-NEXT: store i8* [[COPY]], i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TMP]]) [[NUW]]
 
   x = [x copy];
 
   // Cleanup for x.
   // CHECK-NEXT: [[TMP:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TMP]]) [[NUW]]
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define i8* @test4()
 id test4() {
   // Call to +alloc.
   // CHECK:      load {{.*}}, {{.*}}* @"OBJC_CLASSLIST_REFERENCES_
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
   // CHECK-NEXT: [[ALLOC:%.*]] = bitcast
 
   // Call to -initWith: with elided retain of consumed argument.
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[ALLOC:%.*]] = bitcast
   // CHECK-NEXT: [[INIT:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* [[ALLOC]],
 
   // Initialization of return value, occurring within full-expression.
   // Retain/release elided.
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: [[INIT:%.*]] = bitcast
-  // CHECK-NEXT: [[RET:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[INIT]])
+  // CHECK-NEXT: [[RET:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[INIT]])
 
   // CHECK-NEXT: ret i8* [[RET]]
 
   return [[Test3 alloc] initWith: 6];
 }
 
 @interface Test5 {
 @public
   id var;
 }
 @end
 
 // CHECK-LABEL: define void @test5
 void test5(Test5 *x, id y) {
   // Prologue.
   // CHECK:      [[X:%.*]] = alloca [[TEST5:%.*]]*,
   // CHECK-NEXT: [[Y:%.*]] = alloca i8*
   // CHECK-NEXT: bitcast [[TEST5]]* {{%.*}} to i8*
-  // CHECK-NEXT: call i8* @objc_retain
+  // CHECK-NEXT: call i8* @llvm.objc.retain
   // CHECK-NEXT: [[PARMX:%.*]] = bitcast i8* {{%.*}} to [[TEST5]]*
   // CHECK-NEXT: store [[TEST5]]* [[PARMX]], [[TEST5]]** [[X]]
-  // CHECK-NEXT: call i8* @objc_retain
+  // CHECK-NEXT: call i8* @llvm.objc.retain
   // CHECK-NEXT: store
 
   // CHECK-NEXT: load [[TEST5]]*, [[TEST5]]** [[X]]
   // CHECK-NEXT: load i64, i64* @"OBJC_IVAR_$_Test5.var"
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: getelementptr
   // CHECK-NEXT: [[VAR:%.*]] = bitcast
   // CHECK-NEXT: [[TMP:%.*]] = load i8*, i8** [[VAR]]
   // CHECK-NEXT: store i8* null, i8** [[VAR]]
-  // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TMP]]) [[NUW]]
   x->var = 0;
 
   // CHECK-NEXT: [[YVAL:%.*]] = load i8*, i8** [[Y]]
   // CHECK-NEXT: load [[TEST5]]*, [[TEST5]]** [[X]]
   // CHECK-NEXT: load i64, i64* @"OBJC_IVAR_$_Test5.var"
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: getelementptr
   // CHECK-NEXT: [[VAR:%.*]] = bitcast
-  // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* [[YVAL]]) [[NUW]]
+  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* [[YVAL]]) [[NUW]]
   // CHECK-NEXT: [[TMP:%.*]] = load i8*, i8** [[VAR]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[VAR]]
-  // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TMP]]) [[NUW]]
   x->var = y;
 
   // Epilogue.
   // CHECK-NEXT: [[TMP:%.*]] = load i8*, i8** [[Y]]
-  // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TMP]]) [[NUW]]
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST5]]*, [[TEST5]]** [[X]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST5]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]]
   // CHECK-NEXT: ret void
 }
 
 id test6_helper(void) __attribute__((ns_returns_retained));
 // CHECK-LABEL: define void @test6()
 void test6() {
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test6_helper()
   // CHECK-NEXT: store i8* [[CALL]], i8** [[X]]
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
   id x = test6_helper();
 }
 
 void test7_helper(id __attribute__((ns_consumed)));
 // CHECK-LABEL: define void @test7()
 void test7() {
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: store i8* null, i8** [[X]]
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]]) [[NUW]]
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) [[NUW]]
   // CHECK-NEXT: call void @test7_helper(i8* [[T1]])
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
   id x;
   test7_helper(x);
 }
 
 id test8_helper(void) __attribute__((ns_returns_retained));
 void test8() {
   __unsafe_unretained id x = test8_helper();
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = call i8* @test8_helper()
   // CHECK-NEXT: store i8* [[T0]], i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 @interface Test10
 @property (retain) Test10 *me;
 @end
void test10() {
   // CHECK-NEXT: store [[TEST10]]* null, [[TEST10]]** [[X]]
   // CHECK-NEXT: [[YPTR1:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[YPTR1]])
   // CHECK-NEXT: load [[TEST10]]*, [[TEST10]]** [[X]], align
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_{{[0-9]*}}
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: [[T0:%.*]] = call [[TEST10]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[V:%.*]] = bitcast i8* [[T2]] to [[TEST10]]*
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_{{[0-9]*}}
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: [[T0:%.*]] = call [[TEST10]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST10]]*
   // CHECK-NEXT: [[T4:%.*]] = bitcast [[TEST10]]* [[T3]] to i8*
   // CHECK-NEXT: store i8* [[T4]], i8** [[Y]]
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST10]]* [[V]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: [[YPTR2:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: void @llvm.lifetime.end.p0i8(i64 8, i8* [[YPTR2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST10]]*, [[TEST10]]** [[X]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast [[TEST10]]** [[X]] to i8*
   // CHECK-NEXT: void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 void test11(id (*f)(void) __attribute__((ns_returns_retained))) {
   // CHECK-LABEL:      define void @test11(
   // CHECK:      [[F:%.*]] = alloca i8* ()*, align
   // CHECK-NEXT: [[X:%.*]] = alloca i8*, align
   // CHECK-NEXT: store i8* ()* {{%.*}}, i8* ()** [[F]], align
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = load i8* ()*, i8* ()** [[F]], align
   // CHECK-NEXT: [[T1:%.*]] = call i8* [[T0]]()
   // CHECK-NEXT: store i8* [[T1]], i8** [[X]], align
   // CHECK-NEXT: [[T3:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T3]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T3]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
   id x = f();
 }
 
 void test12(void) {
   extern id test12_helper(void);
 
   // CHECK-LABEL:      define void @test12()
   // CHECK:      [[X:%.*]] = alloca i8*, align
   // CHECK-NEXT: [[Y:%.*]] = alloca i8*, align
 
   __weak id x = test12_helper();
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = call i8* @test12_helper()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
-  // CHECK-NEXT: call i8* @objc_initWeak(i8** [[X]], i8* [[T1]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[X]], i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 
   x = test12_helper();
   // CHECK-NEXT: [[T0:%.*]] = call i8* @test12_helper()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
-  // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[X]], i8* [[T1]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[X]], i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 
   id y = x;
   // CHECK-NEXT: [[YPTR1:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[YPTR1]])
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_loadWeakRetained(i8** [[X]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[X]])
   // CHECK-NEXT: store i8* [[T2]], i8** [[Y]], align
 
   // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** [[Y]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T4]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T4]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[YPTR2:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: void @llvm.lifetime.end.p0i8(i64 8, i8* [[YPTR2]])
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** [[X]])
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[X]])
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK: ret void
 }
 
 // Indirect consuming calls.
 void test13(void) {
   // CHECK-LABEL:      define void @test13()
   // CHECK:      [[X:%.*]] = alloca i8*, align
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: store i8* null, i8** [[X]], align
   id x;
 
   typedef void fnty(id __attribute__((ns_consumed)));
   extern fnty *test13_func;
   // CHECK-NEXT: [[FN:%.*]] = load void (i8*)*, void (i8*)** @test13_func, align
   // CHECK-NEXT: [[X_VAL:%.*]] = load i8*, i8** [[X]], align
-  // CHECK-NEXT: [[X_TMP:%.*]] = call i8* @objc_retain(i8* [[X_VAL]]) [[NUW]]
+  // CHECK-NEXT: [[X_TMP:%.*]] = call i8* @llvm.objc.retain(i8* [[X_VAL]]) [[NUW]]
   // CHECK-NEXT: call void [[FN]](i8* [[X_TMP]])
   test13_func(x);
 
   extern fnty ^test13_block;
   // CHECK-NEXT: [[TMP:%.*]] = load void (i8*)*, void (i8*)** @test13_block, align
   // CHECK-NEXT: [[BLOCK:%.*]] = bitcast void (i8*)* [[TMP]] to [[BLOCKTY:%.*]]*
   // CHECK-NEXT: [[BLOCK_FN_PTR:%.*]] = getelementptr inbounds [[BLOCKTY]], [[BLOCKTY]]* [[BLOCK]], i32 0, i32 3
   // CHECK-NEXT: [[BLOCK_OPAQUE:%.*]] = bitcast [[BLOCKTY]]* [[BLOCK]] to i8*
   // CHECK-NEXT: [[X_VAL:%.*]] = load i8*, i8** [[X]], align
-  // CHECK-NEXT: [[X_TMP:%.*]] = call i8* @objc_retain(i8* [[X_VAL]]) [[NUW]]
+  // CHECK-NEXT: [[X_TMP:%.*]] = call i8* @llvm.objc.retain(i8* [[X_VAL]]) [[NUW]]
   // CHECK-NEXT: [[BLOCK_FN_TMP:%.*]] = load i8*, i8** [[BLOCK_FN_PTR]]
   // CHECK-NEXT: [[BLOCK_FN:%.*]] = bitcast i8* [[BLOCK_FN_TMP]] to void (i8*, i8*)*
   // CHECK-NEXT: call void [[BLOCK_FN]](i8* [[BLOCK_OPAQUE]], i8* [[X_TMP]])
   test13_block(x);
 
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]]
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 @interface Test16_super @end
 @interface Test16 : Test16_super {
   id z;
// .cxx_destruct
   // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
   // CHECK-NEXT: [[BASE:%.*]] = load [[TEST16]]*, [[TEST16]]** [[SELF]]
 
   // Destroy y.
   // CHECK-NEXT: [[Y_OFF:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test16.y"
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST16]]* [[BASE]] to i8*
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 [[Y_OFF]]
   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to i8**
-  // CHECK-NEXT: call void @objc_storeStrong(i8** [[T2]], i8* null) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T2]], i8* null) [[NUW]]
 
   // Destroy z.
   // CHECK-NEXT: [[Z_OFF:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test16.z"
   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST16]]* [[BASE]] to i8*
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 [[Z_OFF]]
   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to i8**
-  // CHECK-NEXT: call void @objc_storeStrong(i8** [[T2]], i8* null) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T2]], i8* null) [[NUW]]
 
   // CHECK-NEXT: ret void
 
 @end
 
 // This shouldn't crash.
 @interface Test17A
 @property (assign) int x;
void test19() {
   // CHECK-NEXT: [[T0:%.*]] = bitcast [5 x i8*]* [[X]] to i8*
   // CHECK: call void @llvm.memset.p0i8.i64(i8* align 16 [[T0]], i8 0, i64 40, i1 false)
   id x[5];
 
   extern id test19_helper(void);
   x[2] = test19_helper();
 
   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test19_helper()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]]) [[NUW]]
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[CALL]]) [[NUW]]
   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[X]], i64 0, i64 2
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[SLOT]]
   // CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]]
 
   // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[X]], i32 0, i32 0
   // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8*, i8** [[BEGIN]], i64 5
   // CHECK-NEXT: br label
 
   // CHECK:      [[AFTER:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
   // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds i8*, i8** [[AFTER]], i64 -1
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[CUR]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[EQ:%.*]] = icmp eq i8** [[CUR]], [[BEGIN]]
   // CHECK-NEXT: br i1 [[EQ]],
 
   // CHECK:      ret void
 }
 
 void test20(unsigned n) {
   // CHECK-LABEL: define void @test20
void test20(unsigned n) {
   // Destroy.
   // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8*, i8** [[VLA]], i64 [[DIM]]
   // CHECK-NEXT: [[EMPTY:%.*]] = icmp eq i8** [[VLA]], [[END]]
   // CHECK-NEXT: br i1 [[EMPTY]]
 
   // CHECK:      [[AFTER:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
   // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds i8*, i8** [[AFTER]], i64 -1
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[CUR]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[EQ:%.*]] = icmp eq i8** [[CUR]], [[VLA]]
   // CHECK-NEXT: br i1 [[EQ]],
 
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[SAVED_STACK]]
   // CHECK-NEXT: call void @llvm.stackrestore(i8* [[T0]])
   // CHECK-NEXT: ret void
 }
 
void test21(unsigned n) {
   // CHECK-NEXT: [[T1:%.*]] = mul nuw i64 [[T0]], 3
   // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8*, i8** [[BEGIN]], i64 [[T1]]
   // CHECK-NEXT: [[EMPTY:%.*]] = icmp eq i8** [[BEGIN]], [[END]]
   // CHECK-NEXT: br i1 [[EMPTY]]
 
   // CHECK:      [[AFTER:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
   // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds i8*, i8** [[AFTER]], i64 -1
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[CUR]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
   // CHECK-NEXT: [[EQ:%.*]] = icmp eq i8** [[CUR]], [[BEGIN]]
   // CHECK-NEXT: br i1 [[EQ]],
 
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[SAVED_STACK]]
   // CHECK-NEXT: call void @llvm.stackrestore(i8* [[T0]])
   // CHECK-NEXT: ret void
 }
 

 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST26]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 [[OFFSET]]
 // CHECK-NEXT: [[X:%.*]] = bitcast i8* [[T1]] to [4 x i8*]*
 // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[X]], i32 0, i32 0
 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8*, i8** [[BEGIN]], i64 4
 // CHECK-NEXT: br label
 // CHECK:      [[PAST:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
 // CHECK-NEXT: [[CUR]] = getelementptr inbounds i8*, i8** [[PAST]], i64 -1
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[CUR]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[CUR]], i8* null)
 // CHECK-NEXT: [[ISDONE:%.*]] = icmp eq i8** [[CUR]], [[BEGIN]]
 // CHECK-NEXT: br i1 [[ISDONE]],
 // CHECK:      ret void
 
 // Check that 'init' retains self.
 @interface Test27
 - (id) init;
 @end
 @implementation Test27
 - (id) init { return self; }
 // CHECK:    define internal i8* @"\01-[Test27 init]"
 // CHECK:      [[SELF:%.*]] = alloca [[TEST27:%.*]]*,
 // CHECK-NEXT: [[CMD:%.*]] = alloca i8*,
 // CHECK-NEXT: store [[TEST27]]* {{%.*}}, [[TEST27]]** [[SELF]]
 // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST27]]*, [[TEST27]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST27]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST27]]*
 // CHECK-NEXT: [[RET:%.*]] = bitcast [[TEST27]]* [[T3]] to i8*
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST27]]*, [[TEST27]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST27]]* [[T0]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T1]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 // CHECK-NEXT: ret i8* [[RET]]
 
 @end
 
 // rdar://problem/8087194
 @interface Test28
 @property (copy) id prop;
 @end
 @implementation Test28
 @synthesize prop;
 @end
 // CHECK:    define internal void @"\01-[Test28 .cxx_destruct]"
 // CHECK:      [[SELF:%.*]] = load [[TEST28:%.*]]*, [[TEST28:%.*]]**
 // CHECK-NEXT: [[OFFSET:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test28.prop"
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST28]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 [[OFFSET]]
 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T2]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T2]], i8* null)
 // CHECK-NEXT: ret void
 
 @interface Test29_super
 - (id) initWithAllocator: (id) allocator;
 @end
 @interface Test29 : Test29_super
 - (id) init;
 - (id) initWithAllocator: (id) allocator;

 // be detectable because we're supposed to ban accesses to the old
 // self value past the delegate init call.
 // CHECK-NEXT: [[T0:%.*]] = bitcast i8* [[CALL]] to [[TEST29]]*
 // CHECK-NEXT: store [[TEST29]]* [[T0]], [[TEST29]]** [[SELF]]
 
 // Return statement.
 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[CALL]]
 // CHECK-NEXT: [[CALL:%.*]] = bitcast
-// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* [[CALL]]) [[NUW]]
+// CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* [[CALL]]) [[NUW]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[TEST29]]*
 // CHECK-NEXT: [[RET:%.*]] = bitcast [[TEST29]]* [[T1]] to i8*
 
 // Cleanup.
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]*, [[TEST29]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
 
 // Return.
 // CHECK-NEXT: ret i8* [[RET]]
   return [self initWithAllocator: _test29_allocator];
 }
 - (id) initWithAllocator: (id) allocator {
 // CHECK:    define internal i8* @"\01-[Test29 initWithAllocator:]"(
 // CHECK:      [[SELF:%.*]] = alloca [[TEST29]]*, align 8
 // CHECK-NEXT: [[CMD:%.*]] = alloca i8*, align 8
 // CHECK-NEXT: [[ALLOCATOR:%.*]] = alloca i8*, align 8
 // CHECK-NEXT: alloca
 // CHECK-NEXT: store [[TEST29]]* {{%.*}}, [[TEST29]]** [[SELF]]
 // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
-// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* {{%.*}})
+// CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}})
 // CHECK-NEXT: store i8* [[T0]], i8** [[ALLOCATOR]]
 
 // Evaluate arguments.  Note that the send argument is evaluated
 // before the zeroing of self.
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]*, [[TEST29]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[ALLOCATOR]], align 8
 
 // Implicit null of 'self', i.e. direct transfer of ownership.
 // CHECK-NEXT: store [[TEST29]]* null, [[TEST29]]** [[SELF]]
 
 // Actual message send.
 // CHECK:      [[CALL:%.*]] = call {{.*}} @objc_msgSendSuper2
 
 // Implicit write of result back into 'self'.  This is not supposed to
 // be detectable because we're supposed to ban accesses to the old
 // self value past the delegate init call.
 // CHECK-NEXT: [[T0:%.*]] = bitcast i8* [[CALL]] to [[TEST29]]*
 // CHECK-NEXT: store [[TEST29]]* [[T0]], [[TEST29]]** [[SELF]]
 
 // Assignment.
 // CHECK-NEXT: [[T0:%.*]] = bitcast i8* [[CALL]] to [[TEST29]]*
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]]) [[NUW]]
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]]) [[NUW]]
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST29]]*
 // CHECK-NEXT: [[T4:%.*]] = load [[TEST29]]*, [[TEST29]]** [[SELF]], align
 // CHECK-NEXT: store [[TEST29]]* [[T3]], [[TEST29]]** [[SELF]], align
 // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST29]]* [[T4]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T5]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]])
 
 // Return statement.
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]*, [[TEST29]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
-// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* [[T1]]) [[NUW]]
+// CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]]) [[NUW]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[TEST29]]*
 // CHECK-NEXT: [[RET:%.*]] = bitcast [[TEST29]]* [[T1]] to i8*
 
 // Cleanup.
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[ALLOCATOR]]
-// CHECK-NEXT: call void @objc_release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release
 
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]*, [[TEST29]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
 
 // Return.
 // CHECK-NEXT: ret i8* [[RET]]
   self = [super initWithAllocator: allocator];
   return self;
 }
 @end
 

 // Assignment.
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST30_HELPER]]* [[CALL]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = load [[TEST30]]*, [[TEST30]]** [[SELF]]
 // CHECK-NEXT: [[IVAR:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test30.helper"
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST30]]* [[T1]] to i8*
 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds i8, i8* [[T2]], i64 [[IVAR]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to i8**
 // CHECK-NEXT#: [[T5:%.*]] = load i8*, i8** [[T4]]
-// CHECK-NEXT#: [[T6:%.*]] = call i8* @objc_retain(i8* [[T0]])
-// CHECK-NEXT#: call void @objc_release(i8* [[T5]])
+// CHECK-NEXT#: [[T6:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
+// CHECK-NEXT#: call void @llvm.objc.release(i8* [[T5]])
 // CHECK-NEXT: store i8* [[T0]], i8** [[T4]]
 
 // Return.
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST30]]*, [[TEST30]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST30]]* [[T0]] to i8*
-// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[TEST30]]*
 // CHECK-NEXT: [[RET:%.*]] = bitcast [[TEST30]]* [[T1]] to i8*
 
 // Cleanup.
 // CHECK-NEXT: [[T0:%.*]] = load [[TEST30]]*, [[TEST30]]** [[SELF]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST30]]* [[T0]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T1]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
 
 // Epilogue.
 // CHECK-NEXT: ret i8* [[RET]]
   self->helper = [self initHelper];
   return self;
 }
 - (Test30_helper*) initHelper {
 // CHECK:    define internal [[TEST30_HELPER]]* @"\01-[Test30 initHelper]"(
 // CHECK:      alloca
 // CHECK-NEXT: alloca
 // CHECK-NEXT: store
 // CHECK-NEXT: store
 // CHECK-NEXT: ret [[TEST30_HELPER]]* null
   return 0;
 }
 
 @end
 
 __attribute__((ns_returns_retained)) id test32(void) {
 // CHECK-LABEL:    define i8* @test32()
 // CHECK:      [[CALL:%.*]] = call i8* @test32_helper()
-// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]])
+// CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[CALL]])
 // CHECK-NEXT: ret i8* [[T0]]
   extern id test32_helper(void);
   return test32_helper();
 }
 
 @class Test33_a;
 @interface Test33
 - (void) give: (Test33_a **) x;
void test33(Test33 *ptr) {
 
   // CHECK:    define void @test33([[TEST33:%.*]]*
   // CHECK:      [[PTR:%.*]] = alloca [[TEST33]]*
   // CHECK-NEXT: [[A:%.*]] = alloca [[A_T:%.*]]*
   // CHECK-NEXT: [[TEMP0:%.*]] = alloca [[A_T]]*
   // CHECK-NEXT: [[TEMP1:%.*]] = alloca [[A_T]]*
   // CHECK-NEXT: [[TEMP2:%.*]] = alloca [[A_T]]*
   // CHECK-NEXT: bitcast
-  // CHECK-NEXT: objc_retain
+  // CHECK-NEXT: llvm.objc.retain
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: store
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: call void @llvm.lifetime.start
   // CHECK-NEXT: store [[A_T]]* null, [[A_T]]** [[A]]
 
   // CHECK-NEXT: load [[TEST33]]*, [[TEST33]]** [[PTR]]
   // CHECK-NEXT: [[W0:%.*]] = load [[A_T]]*, [[A_T]]** [[A]]
   // CHECK-NEXT: store [[A_T]]* [[W0]], [[A_T]]** [[TEMP0]]
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP0]])
   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]*, [[A_T]]** [[TEMP0]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[A_T]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[A_T]]*
   // CHECK-NEXT: call void (...) @clang.arc.use([[A_T]]* [[W0]]) [[NUW]]
   // CHECK-NEXT: [[T4:%.*]] = load [[A_T]]*, [[A_T]]** [[A]]
   // CHECK-NEXT: store [[A_T]]* [[T3]], [[A_T]]** [[A]]
   // CHECK-NEXT: [[T5:%.*]] = bitcast [[A_T]]* [[T4]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T5]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]])
 
   // CHECK-NEXT: load [[TEST33]]*, [[TEST33]]** [[PTR]]
   // CHECK-NEXT: [[W0:%.*]] = load [[A_T]]*, [[A_T]]** [[A]]
   // CHECK-NEXT: store [[A_T]]* [[W0]], [[A_T]]** [[TEMP1]]
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP1]])
   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]*, [[A_T]]** [[TEMP1]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[A_T]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[A_T]]*
   // CHECK-NEXT: call void (...) @clang.arc.use([[A_T]]* [[W0]]) [[NUW]]
   // CHECK-NEXT: [[T4:%.*]] = load [[A_T]]*, [[A_T]]** [[A]]
   // CHECK-NEXT: store [[A_T]]* [[T3]], [[A_T]]** [[A]]
   // CHECK-NEXT: [[T5:%.*]] = bitcast [[A_T]]* [[T4]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T5]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]])
 
   // CHECK-NEXT: load [[TEST33]]*, [[TEST33]]** [[PTR]]
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[A]])
 
   // CHECK-NEXT: load [[TEST33]]*, [[TEST33]]** [[PTR]]
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[A]])
 
   // 'out'
   // CHECK-NEXT: load [[TEST33]]*, [[TEST33]]** [[PTR]]
   // CHECK-NEXT: store [[A_T]]* null, [[A_T]]** [[TEMP2]]
   // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP2]])
   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]*, [[A_T]]** [[TEMP2]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[A_T]]* [[T0]] to i8*
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[A_T]]*
   // CHECK-NEXT: [[T4:%.*]] = load [[A_T]]*, [[A_T]]** [[A]]
   // CHECK-NEXT: store [[A_T]]* [[T3]], [[A_T]]** [[A]]
   // CHECK-NEXT: [[T5:%.*]] = bitcast [[A_T]]* [[T4]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T5]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]])
 
   // CHECK-NEXT: load
   // CHECK-NEXT: bitcast
-  // CHECK-NEXT: objc_release
+  // CHECK-NEXT: llvm.objc.release
   // CHECK-NEXT: bitcast
   // CHECK-NEXT: call void @llvm.lifetime.end
   // CHECK-NEXT: load
   // CHECK-NEXT: bitcast
-  // CHECK-NEXT: objc_release
+  // CHECK-NEXT: llvm.objc.release
   // CHECK-NEXT: ret void
 }
 
 
 // CHECK-LABEL: define void @test36
 void test36(id x) {
   // CHECK: [[X:%.*]] = alloca i8*
 
-  // CHECK: call i8* @objc_retain
-  // CHECK: call i8* @objc_retain
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
+  // CHECK: call i8* @llvm.objc.retain
+  // CHECK: call i8* @llvm.objc.retain
   id array[3] = { @"A", x, @"y" };
 
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[X]]
   // CHECK-NEXT: store i8* null, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   x = 0;
 
   // CHECK: br label
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: br i1
 
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: ret void
 }
 
 @class Test37;
 void test37(void) {
   extern void test37_helper(id *);
   Test37 *var;
   test37_helper(&var);
 
   // CHECK-LABEL:    define void @test37()
   // CHECK:      [[VAR:%.*]] = alloca [[TEST37:%.*]]*,
   // CHECK-NEXT: [[TEMP:%.*]] = alloca i8*
   // CHECK-NEXT: [[VARPTR1:%.*]] = bitcast [[TEST37]]** [[VAR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[VARPTR1]])
   // CHECK-NEXT: store [[TEST37]]* null, [[TEST37]]** [[VAR]]
 
   // CHECK-NEXT: [[W0:%.*]] = load [[TEST37]]*, [[TEST37]]** [[VAR]]
   // CHECK-NEXT: [[W1:%.*]] = bitcast [[TEST37]]* [[W0]] to i8*
   // CHECK-NEXT: store i8* [[W1]], i8** [[TEMP]]
   // CHECK-NEXT: call void @test37_helper(i8** [[TEMP]])
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[TEMP]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[TEST37]]*
   // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST37]]* [[T1]] to i8*
-  // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retain(i8* [[T2]])
+  // CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.retain(i8* [[T2]])
   // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to [[TEST37]]*
   // CHECK-NEXT: call void (...) @clang.arc.use(i8* [[W1]]) [[NUW]]
   // CHECK-NEXT: [[T5:%.*]] = load [[TEST37]]*, [[TEST37]]** [[VAR]]
   // CHECK-NEXT: store [[TEST37]]* [[T4]], [[TEST37]]** [[VAR]]
   // CHECK-NEXT: [[T6:%.*]] = bitcast [[TEST37]]* [[T5]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T6]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T6]])
 
   // CHECK-NEXT: [[T0:%.*]] = load [[TEST37]]*, [[TEST37]]** [[VAR]]
   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST37]]* [[T0]] to i8*
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   // CHECK-NEXT: [[VARPTR2:%.*]] = bitcast [[TEST37]]** [[VAR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[VARPTR2]])
   // CHECK-NEXT: ret void
 }
 
 @interface Test43 @end
 @implementation Test43
 - (id) test __attribute__((ns_returns_retained)) {
   extern id test43_produce(void);
   return test43_produce();
   // CHECK:      call i8* @test43_produce()
-  // CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue(
+  // CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue(
   // CHECK-NEXT: ret 
 }
 @end
 
 @interface Test45
 @property (retain) id x;
 @end
 @implementation Test45
 @synthesize x;
 @end
 // CHECK:    define internal i8* @"\01-[Test45 x]"(
 // CHECK:      [[CALL:%.*]] = tail call i8* @objc_getProperty(
 // CHECK-NEXT: ret i8* [[CALL]]
 
 // rdar://problem/9315552
 void test46(__weak id *wp, __weak volatile id *wvp) {
   extern id test46_helper(void);
 
   // TODO: this is sub-optimal, we should retain at the actual call site.
 
   // CHECK:      [[T0:%.*]] = call i8* @test46_helper()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = load i8**, i8*** {{%.*}}, align 8
-  // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
-  // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_retain(i8* [[T3]])
+  // CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[T2]], i8* [[T1]])
+  // CHECK-NEXT: [[T4:%.*]] = call i8* @llvm.objc.retain(i8* [[T3]])
   // CHECK-NEXT: store i8* [[T4]], i8**
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   id x = *wp = test46_helper();
 
   // CHECK:      [[T0:%.*]] = call i8* @test46_helper()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = load i8**, i8*** {{%.*}}, align 8
-  // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
-  // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_retain(i8* [[T3]])
+  // CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[T2]], i8* [[T1]])
+  // CHECK-NEXT: [[T4:%.*]] = call i8* @llvm.objc.retain(i8* [[T3]])
   // CHECK-NEXT: store i8* [[T4]], i8**
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   id y = *wvp = test46_helper();
 }
 
 // rdar://problem/9378887
 void test47(void) {
   extern id test47_helper(void);
   id x = x = test47_helper();
 
   // CHECK-LABEL:    define void @test47()
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: store i8* null, i8** [[X]]
   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test47_helper()
-  // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]])
+  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[CALL]])
   // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   // CHECK-NEXT: [[T3:%.*]] = load i8*, i8** [[X]]
   // CHECK-NEXT: store i8* [[T2]], i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T3]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T3]])
   // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T4]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T4]])
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 void test48(void) {
   extern id test48_helper(void);
   __weak id x = x = test48_helper();
   // CHECK-LABEL:    define void @test48()
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
-  // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_initWeak(i8** [[X]], i8* null)
+  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.initWeak(i8** [[X]], i8* null)
   // CHECK-NEXT: [[T1:%.*]] = call i8* @test48_helper()
-  // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
-  // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[X]], i8* [[T2]])
-  // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_storeWeak(i8** [[X]], i8* [[T3]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T2]])
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** [[X]])
+  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[X]], i8* [[T2]])
+  // CHECK-NEXT: [[T4:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[X]], i8* [[T3]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[X]])
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 void test49(void) {
   extern id test49_helper(void);
   __autoreleasing id x = x = test49_helper();
   // CHECK-LABEL:    define void @test49()
   // CHECK:      [[X:%.*]] = alloca i8*
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK-NEXT: store i8* null, i8** [[X]]
   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test49_helper()
-  // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]])
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_autorelease(i8* [[T0]])
+  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[CALL]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.autorelease(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T2]], i8** [[X]]
-  // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]])
+  // CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
   // CHECK-NEXT: store i8* [[T3]], i8** [[X]]
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // rdar://9380136
 id x();
 void test50(id y) {
   ({x();});
-// CHECK: [[T0:%.*]] = call i8* @objc_retain
-// CHECK: call void @objc_release
+// CHECK: [[T0:%.*]] = call i8* @llvm.objc.retain
+// CHECK: call void @llvm.objc.release
 }
 
 
 // rdar://9400762
 struct CGPoint {
   float x;
   float y;
 };

 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* [[XPTR1]])
 // CHECK-NEXT: store i32 5, i32* [[X]],
 // CHECK-NEXT: [[T0:%.*]] = load i32, i32* [[X]],
 // CHECK-NEXT: [[T1:%.*]] = call i8* @test52_helper(i32 [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[TMPALLOCA]]
 // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i32* [[X]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* [[XPTR2]])
 // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[TMPALLOCA]]
-// CHECK-NEXT: [[T3:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[T2]])
+// CHECK-NEXT: [[T3:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T2]])
 // CHECK-NEXT: ret i8* [[T3]]
 }
 
 // rdar://problem/9400644
 void test53(void) {
   id test53_helper(void);
   id x = ({ id y = test53_helper(); y; });
   (void) x;
 // CHECK-LABEL:    define void @test53()
 // CHECK:      [[X:%.*]] = alloca i8*,
 // CHECK-NEXT: [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: [[TMPALLOCA:%.*]] = alloca i8*,
 // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
 // CHECK-NEXT: [[YPTR1:%.*]] = bitcast i8** [[Y]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[YPTR1]])
 // CHECK-NEXT: [[T0:%.*]] = call i8* @test53_helper()
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[Y]],
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]],
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[TMPALLOCA]]
 // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[Y]]
-// CHECK-NEXT: call void @objc_release(i8* [[T2]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
 // CHECK-NEXT: [[YPTR2:%.*]] = bitcast i8** [[Y]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[YPTR2]])
 // CHECK-NEXT: [[T3:%.*]] = load i8*, i8** [[TMPALLOCA]]
 // CHECK-NEXT: store i8* [[T3]], i8** [[X]],
 // CHECK-NEXT: load i8*, i8** [[X]],
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-// CHECK-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
 // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
 // CHECK-NEXT: ret void
 }
 
 // <rdar://problem/9758798>
 // CHECK-LABEL: define void @test54(i32 %first, ...)
 void test54(int first, ...) {
   __builtin_va_list arglist;
   // CHECK: call void @llvm.va_start
   __builtin_va_start(arglist, first);
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   id obj = __builtin_va_arg(arglist, id);
   // CHECK: call void @llvm.va_end
   __builtin_va_end(arglist);
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: ret void
 }
 
 // PR10228
 @interface Test55Base @end
 @interface Test55 : Test55Base @end
 @implementation Test55 (Category)
 - (void) dealloc {}
 @end
 // CHECK:   define internal void @"\01-[Test55(Category) dealloc]"(
 // CHECK-NOT: ret
 // CHECK:     call void bitcast (i8* ({{%.*}}*, i8*, ...)* @objc_msgSendSuper2 to void ({{%.*}}*, i8*)*)(
 
 // rdar://problem/8024350
 @protocol Test56Protocol
 + (id) make __attribute__((ns_returns_retained));
 @end
 @interface Test56<Test56Protocol> @end
 @implementation Test56
 // CHECK: define internal i8* @"\01+[Test56 make]"(
 + (id) make {
   extern id test56_helper(void);
   // CHECK:      [[T0:%.*]] = call i8* @test56_helper()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: ret i8* [[T1]]
   return test56_helper();
 }
 @end
 void test56_test(void) {
   id x = [Test56 make];
   // CHECK-LABEL: define void @test56_test()
   // CHECK:      [[X:%.*]] = alloca i8*, align 8
   // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
   // CHECK:      [[T0:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(
   // CHECK-NEXT: store i8* [[T0]], i8** [[X]]
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // rdar://problem/9784964
 @interface Test57
 @property (nonatomic, strong) id strong;

 // CHECK-NEXT: ret i8* [[T5]]
 
 // CHECK: define internal i8* @"\01-[Test57 weak]"(
 // CHECK:      [[T0:%.*]] = load [[TEST57]]*, [[TEST57]]** {{%.*}}
 // CHECK-NEXT: [[T1:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test57.weak"
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST57]]* [[T0]] to i8*
 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds i8, i8* [[T2]], i64 [[T1]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to i8**
-// CHECK-NEXT: [[T5:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T4]])
-// CHECK-NEXT: [[T6:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[T5]])
+// CHECK-NEXT: [[T5:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T4]])
+// CHECK-NEXT: [[T6:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T5]])
 // CHECK-NEXT: ret i8* [[T6]]
 
 // CHECK: define internal i8* @"\01-[Test57 unsafe]"(
 // CHECK:      [[T0:%.*]] = load [[TEST57]]*, [[TEST57]]** {{%.*}}
 // CHECK-NEXT: [[T1:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test57.unsafe"
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST57]]* [[T0]] to i8*
 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds i8, i8* [[T2]], i64 [[T1]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to i8**
 // CHECK-NEXT: [[T5:%.*]] = load i8*, i8** [[T4]]
 // CHECK-NEXT: ret i8* [[T5]]
 
 // rdar://problem/9842343
 void test59(void) {
   extern id test59_getlock(void);
   extern void test59_body(void);
   @synchronized (test59_getlock()) {
     test59_body();
   }
 
   // CHECK-LABEL:    define void @test59()
   // CHECK:      [[T0:%.*]] = call i8* @test59_getlock()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: call i32 @objc_sync_enter(i8* [[T1]])
   // CHECK-NEXT: call void @test59_body()
   // CHECK-NEXT: call i32 @objc_sync_exit(i8* [[T1]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   // CHECK-NEXT: ret void
 }
 
 // Verify that we don't try to reclaim the result of performSelector.
 // rdar://problem/9887545
 @interface Test61
 - (id) performSelector: (SEL) selector;
 - (void) test61_void;
 - (id) test61_id;
 @end
 void test61(void) {
   // CHECK-LABEL:    define void @test61()
   // CHECK:      [[Y:%.*]] = alloca i8*, align 8
 
   extern id test61_make(void);
 
   // CHECK-NEXT: [[T0:%.*]] = call i8* @test61_make()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T3:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T4:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* [[T1]], i8* [[T3]], i8* [[T2]])
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   [test61_make() performSelector: @selector(test61_void)];
 
   // CHECK-NEXT: [[YPTR1:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[YPTR1]])
   // CHECK-NEXT: [[T0:%.*]] = call i8* @test61_make()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T3:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
   // CHECK-NEXT: [[T4:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* [[T1]], i8* [[T3]], i8* [[T2]])
-  // CHECK-NEXT: [[T5:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T4]])
+  // CHECK-NEXT: [[T5:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T4]])
   // CHECK-NEXT: store i8* [[T5]], i8** [[Y]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   id y = [test61_make() performSelector: @selector(test61_id)];
 
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: [[YPTR2:%.*]] = bitcast i8** [[Y]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[YPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // rdar://problem/9891815
 void test62(void) {
   // CHECK-LABEL:    define void @test62()
void test62(void) {
   // CHECK-NEXT: br i1 [[T1]],
 
   for (unsigned i = 0; i != 20; ++i) {
     // CHECK:      [[T0:%.*]] = load i32, i32* [[I]], align 4
     // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
     // CHECK-NEXT: store i1 false, i1* [[CLEANUP_REQUIRED]]
     // CHECK-NEXT: br i1 [[T1]],
     // CHECK:      [[T0:%.*]] = call i8* @test62_make()
-    // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+    // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
     // CHECK-NEXT: store i8* [[T1]], i8** [[CLEANUP_VALUE]]
     // CHECK-NEXT: store i1 true, i1* [[CLEANUP_REQUIRED]]
     // CHECK-NEXT: [[T2:%.*]] = icmp ne i8* [[T1]], null
     // CHECK-NEXT: br label
     // CHECK:      [[COND:%.*]] = phi i1 [ false, {{%.*}} ], [ [[T2]], {{%.*}} ]
     // CHECK-NEXT: [[T0:%.*]] = load i1, i1* [[CLEANUP_REQUIRED]]
     // CHECK-NEXT: br i1 [[T0]],
     // CHECK:      [[T0:%.*]] = load i8*, i8** [[CLEANUP_VALUE]]
-    // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+    // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
     // CHECK-NEXT: br label
     // CHECK:      br i1 [[COND]]
     // CHECK:      call void @test62_body()
     // CHECK-NEXT: br label
     // CHECK:      br label
     if (i != 0 && test62_make() != 0)
       test62_body();
   }

 void test66(void) {
   extern Test66 *test66_receiver(void);
   extern id test66_arg(void);
   [test66_receiver() consume: test66_arg()];
 }
 // CHECK-LABEL:    define void @test66()
 // CHECK:      [[T0:%.*]] = call [[TEST66:%.*]]* @test66_receiver()
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST66]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST66]]*
 // CHECK-NEXT: [[T4:%.*]] = call i8* @test66_arg()
-// CHECK-NEXT: [[T5:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T4]])
+// CHECK-NEXT: [[T5:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T4]])
 // CHECK-NEXT: [[T6:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
 // CHECK-NEXT: [[T7:%.*]] = bitcast [[TEST66]]* [[T3]] to i8*
 // CHECK-NEXT: [[SIX:%.*]] = icmp eq i8* [[T7]], null
 // CHECK-NEXT: br i1 [[SIX]], label [[NULINIT:%.*]], label [[CALL:%.*]]
 // CHECK: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*)*)(i8* [[T7]], i8* [[T6]], i8* [[T5]])
 // CHECK-NEXT: br label [[CONT:%.*]]
-// CHECK: call void @objc_release(i8* [[T5]]) [[NUW]]
+// CHECK: call void @llvm.objc.release(i8* [[T5]]) [[NUW]]
 // CHECK-NEXT: br label [[CONT:%.*]]
 // CHECK: [[T8:%.*]] = bitcast [[TEST66]]* [[T3]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T8]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T8]])
 // CHECK-NEXT: ret void
 
 // rdar://problem/9953540
 Class test67_helper(void);
 void test67(void) {
   Class cl = test67_helper();
 }
 // CHECK-LABEL:    define void @test67()

 void test68(void) {
   __strong Class cl = test67_helper();
 }
 // CHECK-LABEL:    define void @test68()
 // CHECK:      [[CL:%.*]] = alloca i8*, align 8
 // CHECK-NEXT: [[CLPTR1:%.*]] = bitcast i8** [[CL]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CLPTR1]])
 // CHECK-NEXT: [[T0:%.*]] = call i8* @test67_helper()
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[CL]], align 8
 // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[CL]]
-// CHECK-NEXT: call void @objc_release(i8* [[T2]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
 // CHECK-NEXT: [[CLPTR2:%.*]] = bitcast i8** [[CL]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CLPTR2]])
 // CHECK-NEXT: ret void
 
 // rdar://problem/10564852
 @interface Test69 @end
 @implementation Test69
 - (id) foo { return self; }
 @end
 // CHECK: define internal i8* @"\01-[Test69 foo]"(
 // CHECK:      [[SELF:%.*]] = alloca [[TEST69:%.*]]*, align 8
 // CHECK:      [[T0:%.*]] = load [[TEST69]]*, [[TEST69]]** [[SELF]], align 8
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST69]]* [[T0]] to i8*
 // CHECK-NEXT: ret i8* [[T1]]
 
 // rdar://problem/10907547
 void test70(id i) {
   // CHECK-LABEL: define void @test70
   // CHECK: store i8* null, i8**
   // CHECK: store i8* null, i8**
-  // CHECK: [[ID:%.*]] = call i8* @objc_retain(i8*
+  // CHECK: [[ID:%.*]] = call i8* @llvm.objc.retain(i8*
   // CHECK: store i8* [[ID]], i8**
   id x[3] = {
     [2] = i
   };
 }
 
 // Be sure that we emit lifetime intrinsics only after dtors
 struct AggDtor {

test/CodeGenObjC/autorelease.m

- (id) Meth {
    }
   return 0;
 }
 + (id) MyAlloc {
     return 0;
 }
 @end
 
-// CHECK: call i8* @objc_autoreleasePoolPush
+// CHECK: call i8* @llvm.objc.autoreleasePoolPush
 // CHECK: [[T:%.*]] = load i8*, i8** [[A:%.*]]
-// CHECK: call void @objc_autoreleasePoolPop
+// CHECK: call void @llvm.objc.autoreleasePoolPop
 
 // rdar://13660038
 int tryTo(int (*f)(void)) {
   @try {
     @autoreleasepool {
       return f();
     }
   } @catch (...) {
     return 0;
   }
 }
 // CHECK-LABEL:    define i32 @tryTo(i32 ()*
 // CHECK:      [[RET:%.*]] = alloca i32,
-// CHECK:      [[T0:%.*]] = call i8* @objc_autoreleasePoolPush()
+// CHECK:      [[T0:%.*]] = call i8* @llvm.objc.autoreleasePoolPush()
 // CHECK-NEXT: [[T1:%.*]] = load i32 ()*, i32 ()** {{%.*}},
 // CHECK-NEXT: [[T2:%.*]] = invoke i32 [[T1]]()
 // CHECK:      store i32 [[T2]], i32* [[RET]]
 // CHECK:      invoke void @objc_autoreleasePoolPop(i8* [[T0]])
 // CHECK:      landingpad { i8*, i32 }
 // CHECK-NEXT:   catch i8* null
 // CHECK:      call i8* @objc_begin_catch
 // CHECK-NEXT: store i32 0, i32* [[RET]]
 // CHECK:      call void @objc_end_catch()

test/CodeGenObjC/debug-info-block-line.m

 
 @implementation TServer
 - (void)serverConnection:(TConnection *)connection getCommand:(NSString *)str
 {
     NSString    *mapID = nil;
     TMap       *map = [TMap mapForID:mapID];
 // Make sure we do not map code generated for the block to the above line.
 // CHECK: define internal void @"__39-[TServer serverConnection:getCommand:]_block_invoke"
-// CHECK: call void @objc_storeStrong(i8** [[ZERO:%.*]], i8* [[ONE:%.*]]) [[NUW:#[0-9]+]]
-// CHECK: call void @objc_storeStrong(i8** [[TWO:%.*]], i8* [[THREE:%.*]]) [[NUW]]
+// CHECK: call void @llvm.objc.storeStrong(i8** [[ZERO:%.*]], i8* [[ONE:%.*]]) [[NUW:#[0-9]+]]
+// CHECK: call void @llvm.objc.storeStrong(i8** [[TWO:%.*]], i8* [[THREE:%.*]]) [[NUW]]
 // CHECK: call {{.*}}@objc_msgSend{{.*}}, !dbg ![[LINE_ABOVE:[0-9]+]]
 // CHECK: getelementptr
 // CHECK-NOT: !dbg, ![[LINE_ABOVE]]
 // CHECK: bitcast %5** [[TMP:%.*]] to i8**
 // CHECK-NOT: !dbg, ![[LINE_ABOVE]]
-// CHECK: call void @objc_storeStrong(i8** [[VAL1:%.*]], i8* null) [[NUW]]
+// CHECK: call void @llvm.objc.storeStrong(i8** [[VAL1:%.*]], i8* null) [[NUW]]
 // CHECK-NEXT: bitcast %4** [[TMP:%.*]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[VAL2:%.*]], i8* null) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[VAL2:%.*]], i8* null) [[NUW]]
 // CHECK-NEXT: ret
 // CHECK: attributes [[NUW]] = { nounwind }
     [map dataWithCompletionBlock:^(NSData *data, NSError *error) {
         if (data) {
             NSString    *encoded = [[data compressedData] encodedString:18];
             [connection sendResponseCode:TOK dataFollows:YES
                 format:@"Sending \"%@\" (%@)", [map name], [map identifier]];
             [encoded enumerateLinesUsingBlock:^(NSString *line, BOOL *stop) {

test/CodeGenObjC/empty-collection-literals.m

 
 #include "literal-support.h"
 
 void test_empty_array() {
   // CHECK-WITHOUT-EMPTY-COLLECTIONS-LABEL: define void @test_empty_array
   // CHECK-WITHOUT-EMPTY-COLLECTIONS-NOT: ret void
   // CHECK-WITHOUT-EMPTY-COLLECTIONS: {{call.*objc_msgSend}}
   // CHECK-WITHOUT-EMPTY-COLLECTIONS-NOT: ret void
-  // CHECK-WITHOUT-EMPTY-COLLECTIONS: {{call.*objc_retainAutoreleasedReturnValue}}
+  // CHECK-WITHOUT-EMPTY-COLLECTIONS: {{call.*llvm.objc.retainAutoreleasedReturnValue}}
   // CHECK-WITHOUT-EMPTY-COLLECTIONS: ret void
 
   // CHECK-WITH-EMPTY-COLLECTIONS-LABEL: define void @test_empty_array
   // CHECK-WITH-EMPTY-COLLECTIONS-NOT: ret void
   // CHECK-WITH-EMPTY-COLLECTIONS: load {{.*}} @__NSArray0__
   // CHECK-WITH-EMPTY-COLLECTIONS-NOT: ret void
-  // CHECK-WITH-EMPTY-COLLECTIONS: {{call.*objc_retain\(}}
+  // CHECK-WITH-EMPTY-COLLECTIONS: {{call.*llvm.objc.retain\(}}
   // CHECK-WITH-EMPTY-COLLECTIONS-NOT: ret void
-  // CHECK-WITH-EMPTY-COLLECTIONS: call void @objc_storeStrong
+  // CHECK-WITH-EMPTY-COLLECTIONS: call void @llvm.objc.storeStrong
   // CHECK-WITH-EMPTY-COLLECTIONS-NEXT: ret void
   NSArray *arr = @[];
 }
 
 void test_empty_dictionary() {
   // CHECK-WITHOUT-EMPTY-COLLECTIONS-LABEL: define void @test_empty_dictionary
   // CHECK-WITHOUT-EMPTY-COLLECTIONS-NOT: ret void
   // CHECK-WITHOUT-EMPTY-COLLECTIONS: {{call.*objc_msgSend}}
   // CHECK-WITHOUT-EMPTY-COLLECTIONS-NOT: ret void
-  // CHECK-WITHOUT-EMPTY-COLLECTIONS: {{call.*objc_retainAutoreleasedReturnValue}}
+  // CHECK-WITHOUT-EMPTY-COLLECTIONS: {{call.*llvm.objc.retainAutoreleasedReturnValue}}
   // CHECK-WITHOUT-EMPTY-COLLECTIONS: ret void
 
   // CHECK-WITH-EMPTY-COLLECTIONS-LABEL: define void @test_empty_dictionary
   // CHECK-WITH-EMPTY-COLLECTIONS-NOT: ret void
   // CHECK-WITH-EMPTY-COLLECTIONS: load {{.*}} @__NSDictionary0__{{.*}}!invariant.load
   // CHECK-WITH-EMPTY-COLLECTIONS-NOT: ret void
-  // CHECK-WITH-EMPTY-COLLECTIONS: {{call.*objc_retain\(}}
+  // CHECK-WITH-EMPTY-COLLECTIONS: {{call.*llvm.objc.retain\(}}
   // CHECK-WITH-EMPTY-COLLECTIONS-NOT: ret void
-  // CHECK-WITH-EMPTY-COLLECTIONS: call void @objc_storeStrong
+  // CHECK-WITH-EMPTY-COLLECTIONS: call void @llvm.objc.storeStrong
   // CHECK-WITH-EMPTY-COLLECTIONS-NEXT: ret void
   NSDictionary *dict = @{};
 }

test/CodeGenObjC/fragile-arc.m

 - (void) testStrong {
 // CHECK:      [[X:%.*]] = alloca [[OPAQUE:%.*]]*, align 4
 // CHECK:      [[SELF:%.*]] = load [[A]]*, [[A]]** [[SELFVAR]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i32 4
 // CHECK-NEXT: [[IVAR:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]**
 // CHECK-NEXT: [[T0:%.*]] = load [[OPAQUE]]*, [[OPAQUE]]** [[IVAR]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[OPAQUE]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[OPAQUE]]*
 // CHECK-NEXT: store [[OPAQUE]]* [[T3]], [[OPAQUE]]** [[X]]
   Opaque *x = strong;
 // CHECK-NEXT: [[VALUE:%.*]] = load [[OPAQUE]]*, [[OPAQUE]]** [[X]]
 // CHECK-NEXT: [[SELF:%.*]] = load [[A]]*, [[A]]** [[SELFVAR]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i32 4
 // CHECK-NEXT: [[IVAR:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]**
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[OPAQUE]]** [[IVAR]] to i8**
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[OPAQUE]]* [[VALUE]] to i8*
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* [[T1]])
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* [[T1]])
   strong = x;
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[OPAQUE]]** [[X]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define internal void @"\01-[A testWeak]"
 // CHECK:      [[SELFVAR:%.*]] = alloca [[A]]*, align 4
 - (void) testWeak {
 // CHECK:      [[X:%.*]] = alloca [[OPAQUE]]*, align 4
 // CHECK:      [[SELF:%.*]] = load [[A]]*, [[A]]** [[SELFVAR]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i32 8
 // CHECK-NEXT: [[IVAR:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]**
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[OPAQUE]]** [[IVAR]] to i8**
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T0]])
 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]*
 // CHECK-NEXT: store [[OPAQUE]]* [[T2]], [[OPAQUE]]** [[X]]
   Opaque *x = weak;
 // CHECK-NEXT: [[VALUE:%.*]] = load [[OPAQUE]]*, [[OPAQUE]]** [[X]]
 // CHECK-NEXT: [[SELF:%.*]] = load [[A]]*, [[A]]** [[SELFVAR]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i32 8
 // CHECK-NEXT: [[IVAR:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]**
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[OPAQUE]]** [[IVAR]] to i8**
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[OPAQUE]]* [[VALUE]] to i8*
-// CHECK-NEXT: call i8* @objc_storeWeak(i8** [[T0]], i8* [[T1]])
+// CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[T0]], i8* [[T1]])
   weak = x;
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[OPAQUE]]** [[X]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define internal void @"\01-[A .cxx_destruct]"
 // CHECK:      [[SELFVAR:%.*]] = alloca [[A]]*, align 4
 // CHECK:      [[SELF:%.*]] = load [[A]]*, [[A]]** [[SELFVAR]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i32 8
 // CHECK-NEXT: [[IVAR:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]**
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[OPAQUE]]** [[IVAR]] to i8**
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[T0]])
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[T0]])
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[SELF]] to i8*
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i32 4
 // CHECK-NEXT: [[IVAR:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]**
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[OPAQUE]]** [[IVAR]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK-NEXT: ret void
 @end
 
 // Test case for corner case of ivar layout.
 @interface B : A {
   char _b_flag;
 }
 @end

 // CHECK: call void @objc_exception_try_exit
 // CHECK: br label
 // CHECK: call void @checkpoint(i32 3)
 // CHECK: [[EXN:%.*]] = call i8* @objc_exception_extract
 // CHECK: call i32 @objc_exception_match(
 // CHECK: br i1
 // CHECK: [[T0:%.*]] = bitcast i8* [[EXN]] to [[A]]*
 // CHECK: [[T1:%.*]] = bitcast [[A]]* [[T0]] to i8*
-// CHECK: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
+// CHECK: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]])
 // CHECK: [[T3:%.*]] = bitcast i8* [[T2]] to [[A]]*
 // CHECK: store [[A]]* [[T3]], [[A]]** [[X]]
 // CHECK: call void @checkpoint(i32 1)
 // CHECK: [[T0:%.*]] = bitcast [[A]]** [[X]] to i8**
-// CHECK: call void @objc_storeStrong(i8** [[T0]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null)
 // CHECK: br label
-// CHECK: [[T0:%.*]] = call i8* @objc_retain(i8* [[EXN]])
+// CHECK: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* [[EXN]])
 // CHECK: store i8* [[T0]], i8** [[Y]]
 // CHECK: call void @checkpoint(i32 2)
-// CHECK: call void @objc_storeStrong(i8** [[Y]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** [[Y]], i8* null)
 extern void checkpoint(int n);
 void testCatch() {
   @try {
     checkpoint(0);
   } @catch (A *x) {
     checkpoint(1);
   } @catch (id y) {
     checkpoint(2);
   }
   checkpoint(3);
 }

test/CodeGenObjC/mrc-weak.m

 //                         ^ Factory
 @interface Foo : Object {
   __weak id ivar;
 }
 @end
 
 @implementation Foo
 // CHECK-LABEL: define internal void @"\01-[Foo .cxx_destruct]"
-// CHECK: call void @objc_destroyWeak
+// CHECK: call void @llvm.objc.destroyWeak
 @end
 
 
 void test1(__weak id x) {}
 // CHECK-LABEL: define void @test1
 // CHECK:      [[X:%.*]] = alloca i8*,
-// CHECK-NEXT: objc_initWeak
-// CHECK-NEXT: objc_destroyWeak
+// CHECK-NEXT: @llvm.objc.initWeak
+// CHECK-NEXT: @llvm.objc.destroyWeak
 // CHECK-NEXT: ret void
 
 void test2(id y) {
   __weak id z = y;
 }
 // CHECK-LABEL: define void @test2
 // CHECK:      [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: [[Z:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-// CHECK-NEXT: call i8* @objc_initWeak(i8** [[Z]], i8* [[T0]])
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[Z]])
+// CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[Z]], i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[Z]])
 // CHECK-NEXT: ret void
 
 void test3(id y) {
   __weak id z;
   z = y;
 }
 // CHECK-LABEL: define void @test3
 // CHECK:      [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: [[Z:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: store i8* null, i8** [[Z]]
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-// CHECK-NEXT: call i8* @objc_storeWeak(i8** [[Z]], i8* [[T0]])
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[Z]])
+// CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[Z]], i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[Z]])
 // CHECK-NEXT: ret void
 
 void test4(__weak id *p) {
   id y = *p;
 }
 // CHECK-LABEL: define void @test4
 // CHECK:      [[P:%.*]] = alloca i8**,
 // CHECK-NEXT: [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load i8**, i8*** [[P]]
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_loadWeak(i8** [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.loadWeak(i8** [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT: ret void
 
 void test5(__weak id *p) {
   id y = [*p retain];
 }
 // CHECK-LABEL: define void @test5
 // CHECK:      [[P:%.*]] = alloca i8**,
 // CHECK-NEXT: [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load i8**, i8*** [[P]]
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT: ret void
 
 void test6(__weak Foo **p) {
   Foo *y = [*p retain];
 }
 // CHECK-LABEL: define void @test6
 // CHECK:      [[P:%.*]] = alloca [[FOO:%.*]]**,
 // CHECK-NEXT: [[Y:%.*]] = alloca [[FOO]]*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load [[FOO]]**, [[FOO]]*** [[P]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[FOO]]** [[T0]] to i8**
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[FOO]]*
 // CHECK-NEXT: store [[FOO]]* [[T3]], [[FOO]]** [[Y]]
 // CHECK-NEXT: ret void
 
 extern id get_object(void);
 extern void use_block(void (^)(void));
 
 void test7(void) {
   __weak Foo *p = get_object();
   use_block(^{ [p run ]; });
 }
 // CHECK-LABEL: define void @test7
 // CHECK:       [[P:%.*]] = alloca [[FOO]]*,
 // CHECK:       [[T0:%.*]] = call i8* @get_object()
 // CHECK-NEXT:  [[T1:%.*]] = bitcast i8* [[T0]] to [[FOO]]*
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[FOO]]** [[P]] to i8**
 // CHECK-NEXT:  [[T3:%.*]] = bitcast [[FOO]]* [[T1]] to i8*
-// CHECK-NEXT:  call i8* @objc_initWeak(i8** [[T2]], i8* [[T3]])
-// CHECK:       call void @objc_copyWeak
+// CHECK-NEXT:  call i8* @llvm.objc.initWeak(i8** [[T2]], i8* [[T3]])
+// CHECK:       call void @llvm.objc.copyWeak
 // CHECK:       call void @use_block
-// CHECK:       call void @objc_destroyWeak
+// CHECK:       call void @llvm.objc.destroyWeak
 
 // CHECK-LABEL: define linkonce_odr hidden void @__copy_helper_block
-// CHECK:       @objc_copyWeak
+// CHECK:       @llvm.objc.copyWeak
 
 // CHECK-LABEL: define linkonce_odr hidden void @__destroy_helper_block
-// CHECK:       @objc_destroyWeak
+// CHECK:       @llvm.objc.destroyWeak
 
 void test8(void) {
   __block __weak Foo *p = get_object();
   use_block(^{ [p run ]; });
 }
 // CHECK-LABEL: define void @test8
-// CHECK:       call i8* @objc_initWeak
-// CHECK-NOT:   call void @objc_copyWeak
+// CHECK:       call i8* @llvm.objc.initWeak
+// CHECK-NOT:   call void @llvm.objc.copyWeak
 // CHECK:       call void @use_block
-// CHECK:       call void @objc_destroyWeak
+// CHECK:       call void @llvm.objc.destroyWeak
 
 // CHECK-LABEL: define internal void @__Block_byref_object_copy
-// CHECK:       call void @objc_moveWeak
+// CHECK:       call void @llvm.objc.moveWeak
 
 // CHECK-LABEL: define internal void @__Block_byref_object_dispose
-// CHECK:       call void @objc_destroyWeak
+// CHECK:       call void @llvm.objc.destroyWeak
 
 // CHECK-LABEL: define void @test9_baseline()
 // CHECK:       define linkonce_odr hidden void @__copy_helper
 // CHECK:       define linkonce_odr hidden void @__destroy_helper
 void test9_baseline(void) {
   Foo *p = get_object();
   use_block(^{ [p run]; });
 }

test/CodeGenObjC/noescape.m

 // bits of field 'flags' and set the 'isa' field to 'NSConcreteGlobalBlock'.
 
 // CHECK: define void @test6(i8* %{{.*}}, i8* %[[B:.*]])
 // CHECK: %{{.*}} = alloca i8*, align 8
 // CHECK: %[[B_ADDR:.*]] = alloca i8*, align 8
 // CHECK: %[[BLOCK:.*]] = alloca <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, align 8
 // CHECK-NOARC: store i8* %[[B]], i8** %[[B_ADDR]], align 8
 // CHECK-ARC: store i8* null, i8** %[[B_ADDR]], align 8
-// CHECK-ARC: call void @objc_storeStrong(i8** %[[B_ADDR]], i8* %[[B]])
+// CHECK-ARC: call void @llvm.objc.storeStrong(i8** %[[B_ADDR]], i8* %[[B]])
 // CHECK-ARC: %[[V0:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* %[[BLOCK]], i32 0, i32 5
 // CHECK: %[[BLOCK_ISA:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* %[[BLOCK]], i32 0, i32 0
 // CHECK: store i8* bitcast (i8** @_NSConcreteGlobalBlock to i8*), i8** %[[BLOCK_ISA]], align 8
 // CHECK: %[[BLOCK_FLAGS:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* %[[BLOCK]], i32 0, i32 1
 // CHECK: store i32 -796917760, i32* %[[BLOCK_FLAGS]], align 8
 // CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* %[[BLOCK]], i32 0, i32 4
 // CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i64 }* @[[BLOCK_DESCIPTOR_TMP_2]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8
 // CHECK: %[[BLOCK_CAPTURED:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* %[[BLOCK]], i32 0, i32 5
 // CHECK-NOARC: %[[V1:.*]] = load i8*, i8** %[[B_ADDR]], align 8
 // CHECK-NOARC: store i8* %[[V1]], i8** %[[BLOCK_CAPTURED]], align 8
 // CHECK-ARC: %[[V2:.*]] = load i8*, i8** %[[B_ADDR]], align 8
-// CHECK-ARC: %[[V3:.*]] = call i8* @objc_retain(i8* %[[V2]])
+// CHECK-ARC: %[[V3:.*]] = call i8* @llvm.objc.retain(i8* %[[V2]])
 // CHECK-ARC: store i8* %[[V3]], i8** %[[BLOCK_CAPTURED]], align 8
 // CHECK: call void @noescapeFunc0(
-// CHECK-ARC: call void @objc_storeStrong(i8** %[[V0]], i8* null)
-// CHECK-ARC: call void @objc_storeStrong(i8** %[[B_ADDR]], i8* null)
+// CHECK-ARC: call void @llvm.objc.storeStrong(i8** %[[V0]], i8* null)
+// CHECK-ARC: call void @llvm.objc.storeStrong(i8** %[[B_ADDR]], i8* null)
 
 // Non-escaping blocks don't need copy/dispose helper functions.
 
 // CHECK-NOT: define internal void @__copy_helper_block_
 // CHECK-NOT: define internal void @__destroy_helper_block_
 
 void func(id);
 

test/CodeGenObjC/ns_consume_null_check.m

 MyObject *x;
 
 // rdar://10444476
 void test0(void) {
   id obj = [NSObject new];
   [x isEqual : obj];
 }
 // CHECK-LABEL:     define void @test0()
-// CHECK:       [[FIVE:%.*]] = call i8* @objc_retain
+// CHECK:       [[FIVE:%.*]] = call i8* @llvm.objc.retain
 // CHECK-NEXT:  [[SIX:%.*]] = bitcast
 // CHECK-NEXT:  [[SEVEN:%.*]]  = icmp eq i8* [[SIX]], null
 // CHECK-NEXT:  br i1 [[SEVEN]], label [[NULLINIT:%.*]], label [[CALL_LABEL:%.*]]
 // CHECK:       [[FN:%.*]] = load i8*, i8** getelementptr inbounds
 // CHECK-NEXT:  [[EIGHT:%.*]] = bitcast i8* [[FN]]
 // CHECK-NEXT:  [[CALL:%.*]] = call signext i8 [[EIGHT]]
 // CHECK-NEXT:  br label [[CONT:%.*]]
-// CHECK:       call void @objc_release(i8* [[FIVE]]) [[NUW:#[0-9]+]]
+// CHECK:       call void @llvm.objc.release(i8* [[FIVE]]) [[NUW:#[0-9]+]]
 // CHECK-NEXT:  br label [[CONT]]
 // CHECK:       phi i8 [ [[CALL]], {{%.*}} ], [ 0, {{%.*}} ]
 
 // Ensure that we build PHIs correctly in the presence of cleanups.
 // rdar://12046763
 void test1(void) {
   id obj = [NSObject new];
   __weak id weakObj = obj;
   _Complex float result = [x asComplexWithArg: obj];
 }
 // CHECK-LABEL:    define void @test1()
 // CHECK:      [[OBJ:%.*]] = alloca i8*, align 8
 // CHECK-NEXT: [[WEAKOBJ:%.*]] = alloca i8*, align 8
 // CHECK-NEXT: [[RESULT:%.*]] = alloca { float, float }, align 4
 //   Various initializations.
 // CHECK:      [[T0:%.*]] = call i8* bitcast (
 // CHECK-NEXT: store i8* [[T0]], i8** [[OBJ]]
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[OBJ]]
-// CHECK-NEXT: call i8* @objc_initWeak(i8** [[WEAKOBJ]], i8* [[T0]]) [[NUW]]
+// CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[WEAKOBJ]], i8* [[T0]]) [[NUW]]
 //   Okay, start the message-send.
 // CHECK-NEXT: [[T0:%.*]] = load [[MYOBJECT:%.*]]*, [[MYOBJECT:%.*]]** @x
 // CHECK-NEXT: [[ARG:%.*]] = load i8*, i8** [[OBJ]]
-// CHECK-NEXT: [[ARG_RETAINED:%.*]] = call i8* @objc_retain(i8* [[ARG]])
+// CHECK-NEXT: [[ARG_RETAINED:%.*]] = call i8* @llvm.objc.retain(i8* [[ARG]])
 // CHECK-NEXT: load i8*, i8** @
 // CHECK-NEXT: [[SELF:%.*]] = bitcast [[MYOBJECT]]* [[T0]] to i8*
 //   Null check.
 // CHECK-NEXT: [[T0:%.*]] = icmp eq i8* [[SELF]], null
 // CHECK-NEXT: br i1 [[T0]], label [[FORNULL:%.*]], label [[FORCALL:%.*]]
 //   Invoke and produce the return values.
 // CHECK:      [[CALL:%.*]] = invoke <2 x float> bitcast
 // CHECK-NEXT:   to label [[INVOKE_CONT:%.*]] unwind label {{%.*}}
 // CHECK:      [[T0:%.*]] = bitcast { float, float }* [[COERCE:%.*]] to <2 x float>*
 // CHECK-NEXT: store <2 x float> [[CALL]], <2 x float>* [[T0]],
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { float, float }, { float, float }* [[COERCE]], i32 0, i32 0
 // CHECK-NEXT: [[REALCALL:%.*]] = load float, float* [[T0]]
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { float, float }, { float, float }* [[COERCE]], i32 0, i32 1
 // CHECK-NEXT: [[IMAGCALL:%.*]] = load float, float* [[T0]]
 // CHECK-NEXT: br label [[CONT:%.*]]{{$}}
 //   Null path.
-// CHECK:      call void @objc_release(i8* [[ARG_RETAINED]]) [[NUW]]
+// CHECK:      call void @llvm.objc.release(i8* [[ARG_RETAINED]]) [[NUW]]
 // CHECK-NEXT: br label [[CONT]]
 //   Join point.
 // CHECK:      [[REAL:%.*]] = phi float [ [[REALCALL]], [[INVOKE_CONT]] ], [ 0.000000e+00, [[FORNULL]] ]
 // CHECK-NEXT: [[IMAG:%.*]] = phi float [ [[IMAGCALL]], [[INVOKE_CONT]] ], [ 0.000000e+00, [[FORNULL]] ]
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { float, float }, { float, float }* [[RESULT]], i32 0, i32 0
 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds { float, float }, { float, float }* [[RESULT]], i32 0, i32 1
 // CHECK-NEXT: store float [[REAL]], float* [[T0]]
 // CHECK-NEXT: store float [[IMAG]], float* [[T1]]
 //   Epilogue.
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[WEAKOBJ]]) [[NUW]]
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[OBJ]], i8* null) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[WEAKOBJ]]) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[OBJ]], i8* null) [[NUW]]
 // CHECK-NEXT: ret void
 //   Cleanup.
 // CHECK:      landingpad
-// CHECK:      call void @objc_destroyWeak(i8** [[WEAKOBJ]]) [[NUW]]
+// CHECK:      call void @llvm.objc.destroyWeak(i8** [[WEAKOBJ]]) [[NUW]]
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/nsvalue-objc-boxable-ios-arc.m

void doRange() {
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct._NSRange* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct._NSRange* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct._NSRange* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   NSRange ns_range = { .location = 0, .length = 42 };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8* {{.*}}[[RANGE_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *range = @(ns_range);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doPoint()
 void doPoint() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct.CGPoint{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct.CGPoint{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct.CGPoint* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct.CGPoint* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct.CGPoint* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   CGPoint cg_point = { .x = 42, .y = 24 };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8* {{.*}}[[POINT_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *point = @(cg_point);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doSize()
 void doSize() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct.CGSize{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct.CGSize{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct.CGSize* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct.CGSize* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct.CGSize* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   CGSize cg_size = { .width = 42, .height = 24 };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8* {{.*}}[[SIZE_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *size = @(cg_size);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doRect()
 void doRect() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct.CGRect{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct.CGRect{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct.CGRect* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct.CGRect* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct.CGRect* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   CGPoint cg_point = { .x = 42, .y = 24 };
   CGSize cg_size = { .width = 42, .height = 24 };
   CGRect cg_rect = { .origin = cg_point, .size = cg_size };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8*{{.*}}[[RECT_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *rect = @(cg_rect);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doNSEdgeInsets()
 void doNSEdgeInsets() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct.NSEdgeInsets{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct.NSEdgeInsets{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct.NSEdgeInsets* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct.NSEdgeInsets* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct.NSEdgeInsets* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   NSEdgeInsets ns_edge_insets;
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8*{{.*}}[[EDGE_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *edge_insets = @(ns_edge_insets);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doRangeRValue() 
 void doRangeRValue() {
   // CHECK:     [[COERCE:%.*]]          = alloca %struct._NSRange{{.*}}
   // CHECK:     [[RECV_PTR:%.*]]        = load {{.*}} [[NSVALUE]]
   // CHECK:     call {{.*}} @getRange {{.*}} [[COERCE]]{{.*}}
   // CHECK:     [[COERCE_CAST:%.*]]     = bitcast %struct._NSRange* [[COERCE]]{{.*}}
   // CHECK:     [[SEL:%.*]]             = load i8*, i8** [[VALUE_SEL]]
   // CHECK:     [[RECV:%.*]]            = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   // CHECK:     call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[COERCE_CAST]], i8* {{.*}}[[RANGE_STR]]{{.*}})
-  // CHECK:     call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:     call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *range_rvalue = @(getRange());
-  // CHECK:     call void @objc_release
+  // CHECK:     call void @llvm.objc.release
   // CHECK:     ret void
 }
 

test/CodeGenObjC/nsvalue-objc-boxable-mac-arc.m

void doRange() {
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct._NSRange* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct._NSRange* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct._NSRange* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   NSRange ns_range = { .location = 0, .length = 42 };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8* {{.*}}[[RANGE_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *range = @(ns_range);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doPoint()
 void doPoint() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct._NSPoint{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct._NSPoint{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct._NSPoint* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct._NSPoint* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct._NSPoint* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   NSPoint ns_point = { .x = 42, .y = 24 };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8* {{.*}}[[POINT_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *point = @(ns_point);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doSize()
 void doSize() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct._NSSize{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct._NSSize{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct._NSSize* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct._NSSize* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct._NSSize* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   NSSize ns_size = { .width = 42, .height = 24 };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8* {{.*}}[[SIZE_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *size = @(ns_size);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doRect()
 void doRect() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct._NSRect{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct._NSRect{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct._NSRect* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct._NSRect* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct._NSRect* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   NSPoint ns_point = { .x = 42, .y = 24 };
   NSSize ns_size = { .width = 42, .height = 24 };
   NSRect ns_rect = { .origin = ns_point, .size = ns_size };
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8*{{.*}}[[RECT_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *rect = @(ns_rect);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doNSEdgeInsets()
 void doNSEdgeInsets() {
   // CHECK:      [[LOCAL_VAR:%.*]]  = alloca %struct.NSEdgeInsets{{.*}}
   // CHECK:      [[TEMP_VAR:%.*]]   = alloca %struct.NSEdgeInsets{{.*}}
   // CHECK:      [[RECV_PTR:%.*]]   = load {{.*}} [[NSVALUE]]
   // CHECK:      [[TEMP_CAST:%.*]]  = bitcast %struct.NSEdgeInsets* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[LOCAL_CAST:%.*]] = bitcast %struct.NSEdgeInsets* [[LOCAL_VAR]]{{.*}}
   // CHECK:      call void @llvm.memcpy{{.*}} [[TEMP_CAST]]{{.*}} [[LOCAL_CAST]]{{.*}}
   // CHECK:      [[PARAM_CAST:%.*]] = bitcast %struct.NSEdgeInsets* [[TEMP_VAR]]{{.*}}
   // CHECK:      [[SEL:%.*]]        = load i8*, i8** [[VALUE_SEL]]
   // CHECK:      [[RECV:%.*]]       = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   NSEdgeInsets ns_edge_insets;
   // CHECK:      call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[PARAM_CAST]], i8*{{.*}}[[EDGE_STR]]{{.*}})
-  // CHECK:      call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:      call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *edge_insets = @(ns_edge_insets);
-  // CHECK:      call void @objc_release
+  // CHECK:      call void @llvm.objc.release
   // CHECK:      ret void
 }
 
 // CHECK-LABEL: define void @doRangeRValue() 
 void doRangeRValue() {
   // CHECK:     [[COERCE:%.*]]          = alloca %struct._NSRange{{.*}}
   // CHECK:     [[RECV_PTR:%.*]]        = load {{.*}} [[NSVALUE]]
   // CHECK:     [[RVAL:%.*]]            = call {{.*}} @getRange()
   // CHECK:     [[COERCE_CAST:%.*]]     = bitcast %struct._NSRange* [[COERCE]]{{.*}}
   // CHECK:     [[COERCE_CAST_PTR:%.*]] = getelementptr {{.*}} [[COERCE_CAST]], {{.*}}
   // CHECK:     [[EXTR_RVAL:%.*]]       = extractvalue {{.*}} [[RVAL]]{{.*}}
   // CHECK:     store {{.*}}[[EXTR_RVAL]]{{.*}}[[COERCE_CAST_PTR]]{{.*}}
   // CHECK:     [[COERCE_CAST:%.*]]     = bitcast %struct._NSRange* [[COERCE]]{{.*}}
   // CHECK:     [[SEL:%.*]]             = load i8*, i8** [[VALUE_SEL]]
   // CHECK:     [[RECV:%.*]]            = bitcast %struct._class_t* [[RECV_PTR]] to i8*
   // CHECK:     call {{.*objc_msgSend.*}}(i8* [[RECV]], i8* [[SEL]], i8* [[COERCE_CAST]], i8* {{.*}}[[RANGE_STR]]{{.*}})
-  // CHECK:     call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK:     call i8* @llvm.objc.retainAutoreleasedReturnValue
   NSValue *range_rvalue = @(getRange());
-  // CHECK:     call void @objc_release
+  // CHECK:     call void @llvm.objc.release
   // CHECK:     ret void
 }
 

test/CodeGenObjC/objc-arc-container-subscripting.m

 // RUN: %clang_cc1 -fobjc-arc -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s
 
 @interface NSMutableArray
 - (id)objectAtIndexedSubscript:(int)index;
 - (void)setObject:(id)object atIndexedSubscript:(int)index;
 @end
 
 id func() {
   NSMutableArray *array;
   array[3] = 0;
   return array[3];
 }
 
 // CHECK: [[call:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
-// CHECK: [[SIX:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[call]]) [[NUW:#[0-9]+]]
+// CHECK: [[SIX:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[call]]) [[NUW:#[0-9]+]]
 // CHECK: [[ARRAY_CASTED:%.*]] = bitcast %0** {{%.*}} to i8**
-// CHECK: call void @objc_storeStrong(i8** [[ARRAY_CASTED]], i8* null)
-// CHECK: [[EIGHT:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[SIX]]) [[NUW]]
+// CHECK: call void @llvm.objc.storeStrong(i8** [[ARRAY_CASTED]], i8* null)
+// CHECK: [[EIGHT:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[SIX]]) [[NUW]]
 // CHECK: ret i8* [[EIGHT]]
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/os_log.m

 // CHECK-O0-LABEL: define i8* @test_builtin_os_log
 // CHECK: (i8* returned %[[BUF:.*]])
 // CHECK-O0: (i8* %[[BUF:.*]])
 void *test_builtin_os_log(void *buf) {
   return __builtin_os_log_format(buf, "capabilities: %@", GenString());
 
   // CHECK: %[[CALL:.*]] = tail call %[[TY0:.*]]* (...) @GenString()
   // CHECK: %[[V0:.*]] = bitcast %[[TY0]]* %[[CALL]] to i8*
-  // CHECK: %[[V1:.*]] = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %[[V0]])
+  // CHECK: %[[V1:.*]] = tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V0]])
   // CHECK: %[[V2:.*]] = ptrtoint %[[TY0]]* %[[CALL]] to i64
   // CHECK: store i8 2, i8* %[[BUF]], align 1
   // CHECK: %[[NUMARGS_I:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
   // CHECK: store i8 1, i8* %[[NUMARGS_I]], align 1
   // CHECK: %[[ARGDESCRIPTOR_I:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
   // CHECK: store i8 64, i8* %[[ARGDESCRIPTOR_I]], align 1
   // CHECK: %[[ARGSIZE_I:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
   // CHECK: store i8 8, i8* %[[ARGSIZE_I]], align 1
   // CHECK: %[[ARGDATA_I:.*]] = getelementptr i8, i8* %[[BUF]], i64 4
   // CHECK: %[[ARGDATACAST_I:.*]] = bitcast i8* %[[ARGDATA_I]] to i64*
   // CHECK: store i64 %[[V2]], i64* %[[ARGDATACAST_I]], align 1
   // CHECK: tail call void (...) @clang.arc.use(%[[TY0]]* %[[CALL]])
-  // CHECK: tail call void @objc_release(i8* %[[V0]])
+  // CHECK: tail call void @llvm.objc.release(i8* %[[V0]])
   // CHECK: ret i8* %[[BUF]]
 
   // clang.arc.use is used and removed in IR optimizations. At O0, we should not
   // emit clang.arc.use, since it will not be removed and we will have a link
   // error.
   // CHECK-O0: %[[BUF_ADDR:.*]] = alloca i8*, align 8
   // CHECK-O0: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8
   // CHECK-O0: %[[V0:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8
   // CHECK-O0: %[[CALL:.*]] = call %[[TY0:.*]]* (...) @GenString()
   // CHECK-O0: %[[V1:.*]] = bitcast %[[TY0]]* %[[CALL]] to i8*
-  // CHECK-O0: %[[V2:.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* %[[V1]])
+  // CHECK-O0: %[[V2:.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V1]])
   // CHECK-O0: %[[V3:.*]] = bitcast i8* %[[V2]] to %[[TY0]]*
   // CHECK-O0: %[[V4:.*]] = ptrtoint %[[TY0]]* %[[V3]] to i64
   // CHECK-O0: call void @__os_log_helper_1_2_1_8_64(i8* %[[V0]], i64 %[[V4]])
   // CHECK-O0: %[[V5:.*]] = bitcast %[[TY0]]* %[[V3]] to i8*
   // CHECK-O0-NOT call void (...) @clang.arc.use({{.*}}
-  // CHECK-O0: call void @objc_release(i8* %[[V5]])
+  // CHECK-O0: call void @llvm.objc.release(i8* %[[V5]])
   // CHECK-O0: ret i8* %[[V0]]
 }
 
 // CHECK-O0-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_1_8_64
 // CHECK-O0: (i8* %[[BUFFER:.*]], i64 %[[ARG0:.*]])
 
 // CHECK-O0: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
 // CHECK-O0: %[[ARG0_ADDR:.*]] = alloca i64, align 8

test/CodeGenObjC/parameterized_classes.m

void getObjectsTest(NSMutableArray<NSString *> *array) {
   [array getObjects: objects length: &length];
 }
 
 void printMe(NSString *name) { }
 
 // CHECK-LABEL: define void @blockTest
 void blockTest(NSMutableArray<void (^)(void)> *array, NSString *name) {
   // CHECK-NOT: ret void
-  // CHECK: call i8* @objc_retainBlock
+  // CHECK: call i8* @llvm.objc.retainBlock
   [array addObject: ^ { printMe(name); }];
   // CHECK-NOT: ret void
   array[0] = ^ { printMe(name); };
-  // CHECK: call i8* @objc_retainBlock
+  // CHECK: call i8* @llvm.objc.retainBlock
   // CHECK: ret void
 }
 
 // CHECK-LABEL: define internal void @"\01-[Derived setDest:]
 // CHECK: %[[SELFADDR:.*]] = alloca %[[SELFTY:.*]]*
 // CHECK: %[[AADDR:.*]] = alloca %[[IVARTY:.*]]*
 // CHECK: %[[V2:.*]] = load %[[IVARTY]]*, %[[IVARTY]]** %[[AADDR]]
 // CHECK: %[[V3:.*]] = load %[[SELFTY]]*, %[[SELFTY]]** %[[SELFADDR]]
 // CHECK: %[[IVAR:.*]] = load i64, i64* @"OBJC_IVAR_$_Base._destination"
 // CHECK: %[[V4:.*]] = bitcast %[[SELFTY]]* %[[V3]] to i8*
 // CHECK: %[[ADDPTR:.*]] = getelementptr inbounds i8, i8* %[[V4]], i64 %[[IVAR]]
 // CHECK: %[[V5:.*]] = bitcast i8* %[[ADDPTR]] to %[[IVARTY]]**
 // CHECK: %[[V6:.*]] = bitcast %[[IVARTY]]** %[[V5]] to i8**
 // CHECK: %[[V7:.*]] = bitcast %[[IVARTY]]* %[[V2]] to i8*
-// CHECK: call void @objc_storeStrong(i8** %[[V6]], i8* %[[V7]])
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V6]], i8* %[[V7]])
 
 @interface Base<DestType> : NSObject {
   DestType _destination;
 }
 @end
 
 @interface Derived : Base<NSObject *>
 - (void)setDest:(NSObject *)a;

test/CodeGenObjC/stret-lifetime.m

void foo(id o, id p) {
   // ARC: [[T0:%.*]] = icmp eq i8*
   // ARC: br i1 [[T0]]
 
   // CHECK: @llvm.lifetime.start
   // CHECK: call void bitcast {{.*}} @objc_msgSend
   // CHECK: @llvm.lifetime.end
   // ARC: br label
 
-  // ARC: call void @objc_release
+  // ARC: call void @llvm.objc.release
   // ARC: br label
 
   // CHECK-NOT: call void @llvm.memset
 }

test/CodeGenObjC/strong-in-c-struct.m

 // CHECK: define linkonce_odr hidden void @__destructor_8_s16_s24(i8** %[[DST:.*]])
 // CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
 // CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
 // CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
 // CHECK: call void @__destructor_8_s16(i8** %[[V0]])
 // CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8*
 // CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 24
 // CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8**
-// CHECK: call void @objc_storeStrong(i8** %[[V3]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V3]], i8* null)
 // CHECK: ret void
 
 // CHECK: define linkonce_odr hidden void @__destructor_8_s16(i8** %[[DST:.*]])
 // CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
 // CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
 // CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
 // CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8*
 // CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 16
 // CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8**
-// CHECK: call void @objc_storeStrong(i8** %[[V3]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V3]], i8* null)
 // CHECK: ret void
 
 void test_constructor_destructor_StrongOuter(void) {
   StrongOuter t;
 }
 
 // CHECK: define void @test_copy_constructor_StrongOuter(%[[STRUCT_STRONGOUTER:.*]]* %[[S:.*]])
 // CHECK: %[[S_ADDR:.*]] = alloca %[[STRUCT_STRONGOUTER]]*, align 8

 // CHECK: call void @__copy_constructor_8_8_t0w16_s16(i8** %[[V0]], i8** %[[V1]])
 // CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
 // CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 24
 // CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
 // CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 24
 // CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
 // CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
-// CHECK: %[[V9:.*]] = call i8* @objc_retain(i8* %[[V8]])
+// CHECK: %[[V9:.*]] = call i8* @llvm.objc.retain(i8* %[[V8]])
 // CHECK: store i8* %[[V9]], i8** %[[V4]], align 8
 // CHECK: %[[V10:.*]] = bitcast i8** %[[V0]] to i8*
 // CHECK: %[[V11:.*]] = getelementptr inbounds i8, i8* %[[V10]], i64 32
 // CHECK: %[[V12:.*]] = bitcast i8* %[[V11]] to i8**
 // CHECK: %[[V13:.*]] = bitcast i8** %[[V1]] to i8*
 // CHECK: %[[V14:.*]] = getelementptr inbounds i8, i8* %[[V13]], i64 32
 // CHECK: %[[V15:.*]] = bitcast i8* %[[V14]] to i8**
 // CHECK: %[[V16:.*]] = bitcast i8** %[[V12]] to i64*

 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[V2]], i8* align 8 %[[V3]], i64 16, i1 false)
 // CHECK: %[[V4:.*]] = bitcast i8** %[[V0]] to i8*
 // CHECK: %[[V5:.*]] = getelementptr inbounds i8, i8* %[[V4]], i64 16
 // CHECK: %[[V6:.*]] = bitcast i8* %[[V5]] to i8**
 // CHECK: %[[V7:.*]] = bitcast i8** %[[V1]] to i8*
 // CHECK: %[[V8:.*]] = getelementptr inbounds i8, i8* %[[V7]], i64 16
 // CHECK: %[[V9:.*]] = bitcast i8* %[[V8]] to i8**
 // CHECK: %[[V10:.*]] = load i8*, i8** %[[V9]], align 8
-// CHECK: %[[V11:.*]] = call i8* @objc_retain(i8* %[[V10]])
+// CHECK: %[[V11:.*]] = call i8* @llvm.objc.retain(i8* %[[V10]])
 // CHECK: store i8* %[[V11]], i8** %[[V6]], align 8
 // CHECK: ret void
 
 void test_copy_constructor_StrongOuter(StrongOuter *s) {
   StrongOuter t = *s;
 }
 
 /// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_t0w16_s16_s24_t32w8(i8** %[[DST:.*]], i8** %[[SRC:.*]])
 // CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
 // CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
 // CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
 // CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
 // CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
 // CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
 // CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
 // CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 24
 // CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
 // CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 24
 // CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
 // CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
-// CHECK: call void @objc_storeStrong(i8** %[[V4]], i8* %[[V8]])
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V4]], i8* %[[V8]])
 
 void test_copy_assignment_StrongOuter(StrongOuter *d, StrongOuter *s) {
   *d = *s;
 }
 
 // CHECK: define void @test_move_constructor_StrongOuter()
 // CHECK: %[[T1:.*]] = getelementptr inbounds %[[STRUCT_BLOCK_BYREF_T:.*]], %[[STRUCT_BLOCK_BYREF_T]]* %{{.*}}, i32 0, i32 7
 // CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T1]] to i8**

 // CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
 // CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 24
 // CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
 // CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
 // CHECK: store i8* null, i8** %[[V7]], align 8
 // CHECK: %[[V9:.*]] = load i8*, i8** %[[V4]], align 8
 // CHECK: store i8* %[[V8]], i8** %[[V4]], align 8
-// CHECK: call void @objc_release(i8* %[[V9]])
+// CHECK: call void @llvm.objc.release(i8* %[[V9]])
 
 void test_move_assignment_StrongOuter(StrongOuter *p) {
   *p = getStrongOuter();
 }
 
 // CHECK: define void @test_parameter_StrongSmall([2 x i64] %[[A_COERCE:.*]])
 // CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONG:.*]], align 8
 // CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to [2 x i64]*

 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_sb0(i8** %[[DST:.*]], i8** %[[SRC:.*]])
 // CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
 // CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
 // CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
 // CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
 // CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
 // CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
 // CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8
-// CHECK: %[[V3:.*]] = call i8* @objc_retainBlock(i8* %[[V2]])
+// CHECK: %[[V3:.*]] = call i8* @llvm.objc.retainBlock(i8* %[[V2]])
 // CHECK: store i8* %[[V3]], i8** %[[V0]], align 8
 // CHECK: ret void
 
 void test_copy_constructor_StrongBlock(StrongBlock *s) {
   StrongBlock t = *s;
 }
 
 // CHECK: define void @test_copy_assignment_StrongBlock(%[[STRUCT_STRONGBLOCK:.*]]* %[[D:.*]], %[[STRUCT_STRONGBLOCK]]* %[[S:.*]])
 // CHECK: call void @__copy_assignment_8_8_sb0(
 
 // CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_sb0(i8** %[[DST:.*]], i8** %[[SRC:.*]])
 // CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
 // CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
 // CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
 // CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
 // CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
 // CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
 // CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8
-// CHECK: %[[V3:.*]] = call i8* @objc_retainBlock(i8* %[[V2]])
+// CHECK: %[[V3:.*]] = call i8* @llvm.objc.retainBlock(i8* %[[V2]])
 // CHECK: %[[V4:.*]] = load i8*, i8** %[[V0]], align 8
 // CHECK: store i8* %[[V3]], i8** %[[V0]], align 8
-// CHECK: call void @objc_release(i8* %[[V4]])
+// CHECK: call void @llvm.objc.release(i8* %[[V4]])
 // CHECK: ret void
 
 void test_copy_assignment_StrongBlock(StrongBlock *d, StrongBlock *s) {
   *d = *s;
 }
 
 // CHECK: define void @test_copy_constructor_StrongVolatile0(
 // CHECK: call void @__copy_constructor_8_8_t0w4_sv8(
 // CHECK: call void @__destructor_8_sv8(
 
 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w4_sv8(
 // CHECK: %[[V8:.*]] = load volatile i8*, i8** %{{.*}}, align 8
-// CHECK: %[[V9:.*]] = call i8* @objc_retain(i8* %[[V8]])
+// CHECK: %[[V9:.*]] = call i8* @llvm.objc.retain(i8* %[[V8]])
 // CHECK: store volatile i8* %[[V9]], i8** %{{.*}}, align 8
 
 void test_copy_constructor_StrongVolatile0(StrongVolatile *s) {
   StrongVolatile t = *s;
 }
 
 // CHECK: define void @test_copy_constructor_StrongVolatile1(
 // CHECK: call void @__copy_constructor_8_8_tv0w128_sv16(

test/CodeGenObjC/weak-in-c-struct.m

 
 // ARM64: define linkonce_odr hidden void @__destructor_8_w8(i8** %[[DST:.*]])
 // ARM64: %[[DST_ADDR:.*]] = alloca i8**, align 8
 // ARM64: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
 // ARM64: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
 // ARM64: %[[V1:.*]] = bitcast i8** %[[V0]] to i8*
 // ARM64: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 8
 // ARM64: %[[V3:.*]] = bitcast i8* %[[V2]] to i8**
-// ARM64: call void @objc_destroyWeak(i8** %[[V3]])
+// ARM64: call void @llvm.objc.destroyWeak(i8** %[[V3]])
 
 void test_constructor_destructor_Weak(void) {
   Weak t;
 }
 
 // ARM64: define void @test_copy_constructor_Weak(%[[STRUCT_WEAK]]* %{{.*}})
 // ARM64: call void @__copy_constructor_8_8_t0w4_w8(i8** %{{.*}}, i8** %{{.*}})
 // ARM64: call void @__destructor_8_w8(i8** %{{.*}})

 // ARM64: %[[V4:.*]] = load i32, i32* %[[V3]], align 8
 // ARM64: store i32 %[[V4]], i32* %[[V2]], align 8
 // ARM64: %[[V5:.*]] = bitcast i8** %[[V0]] to i8*
 // ARM64: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
 // ARM64: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
 // ARM64: %[[V8:.*]] = bitcast i8** %[[V1]] to i8*
 // ARM64: %[[V9:.*]] = getelementptr inbounds i8, i8* %[[V8]], i64 8
 // ARM64: %[[V10:.*]] = bitcast i8* %[[V9]] to i8**
-// ARM64: call void @objc_copyWeak(i8** %[[V7]], i8** %[[V10]])
+// ARM64: call void @llvm.objc.copyWeak(i8** %[[V7]], i8** %[[V10]])
 
 void test_copy_constructor_Weak(Weak *s) {
   Weak t = *s;
 }
 
 // ARM64: define void @test_copy_assignment_Weak(%[[STRUCT_WEAK]]* %{{.*}}, %[[STRUCT_WEAK]]* %{{.*}})
 // ARM64: call void @__copy_assignment_8_8_t0w4_w8(i8** %{{.*}}, i8** %{{.*}})
 

 // ARM64: %[[V4:.*]] = load i32, i32* %[[V3]], align 8
 // ARM64: store i32 %[[V4]], i32* %[[V2]], align 8
 // ARM64: %[[V5:.*]] = bitcast i8** %[[V0]] to i8*
 // ARM64: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
 // ARM64: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
 // ARM64: %[[V8:.*]] = bitcast i8** %[[V1]] to i8*
 // ARM64: %[[V9:.*]] = getelementptr inbounds i8, i8* %[[V8]], i64 8
 // ARM64: %[[V10:.*]] = bitcast i8* %[[V9]] to i8**
-// ARM64: %[[V11:.*]] = call i8* @objc_loadWeakRetained(i8** %[[V10]])
-// ARM64: %[[V12:.*]] = call i8* @objc_storeWeak(i8** %[[V7]], i8* %[[V11]])
-// ARM64: call void @objc_release(i8* %[[V11]])
+// ARM64: %[[V11:.*]] = call i8* @llvm.objc.loadWeakRetained(i8** %[[V10]])
+// ARM64: %[[V12:.*]] = call i8* @llvm.objc.storeWeak(i8** %[[V7]], i8* %[[V11]])
+// ARM64: call void @llvm.objc.release(i8* %[[V11]])
 
 void test_copy_assignment_Weak(Weak *d, Weak *s) {
   *d = *s;
 }
 
 // ARM64: define internal void @__Block_byref_object_copy_(i8*, i8*)
 // ARM64: call void @__move_constructor_8_8_t0w4_w8(i8** %{{.*}}, i8** %{{.*}})
 

 // ARM64: %[[V4:.*]] = load i32, i32* %[[V3]], align 8
 // ARM64: store i32 %[[V4]], i32* %[[V2]], align 8
 // ARM64: %[[V5:.*]] = bitcast i8** %[[V0]] to i8*
 // ARM64: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
 // ARM64: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
 // ARM64: %[[V8:.*]] = bitcast i8** %[[V1]] to i8*
 // ARM64: %[[V9:.*]] = getelementptr inbounds i8, i8* %[[V8]], i64 8
 // ARM64: %[[V10:.*]] = bitcast i8* %[[V9]] to i8**
-// ARM64: call void @objc_moveWeak(i8** %[[V7]], i8** %[[V10]])
+// ARM64: call void @llvm.objc.moveWeak(i8** %[[V7]], i8** %[[V10]])
 
 void test_move_constructor_Weak(void) {
   __block Weak t;
   BlockTy b = ^{ (void)t; };
 }
 
 // ARM64: define void @test_move_assignment_Weak(%[[STRUCT_WEAK]]* %{{.*}})
 // ARM64: call void @__move_assignment_8_8_t0w4_w8(i8** %{{.*}}, i8** %{{.*}})

 // ARM64: %[[V4:.*]] = load i32, i32* %[[V3]], align 8
 // ARM64: store i32 %[[V4]], i32* %[[V2]], align 8
 // ARM64: %[[V5:.*]] = bitcast i8** %[[V0]] to i8*
 // ARM64: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
 // ARM64: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
 // ARM64: %[[V8:.*]] = bitcast i8** %[[V1]] to i8*
 // ARM64: %[[V9:.*]] = getelementptr inbounds i8, i8* %[[V8]], i64 8
 // ARM64: %[[V10:.*]] = bitcast i8* %[[V9]] to i8**
-// ARM64: %[[V11:.*]] = call i8* @objc_loadWeakRetained(i8** %[[V10]])
-// ARM64: %[[V12:.*]] = call i8* @objc_storeWeak(i8** %[[V7]], i8* %[[V11]])
-// ARM64: call void @objc_destroyWeak(i8** %[[V10]])
-// ARM64: call void @objc_release(i8* %[[V11]])
+// ARM64: %[[V11:.*]] = call i8* @llvm.objc.loadWeakRetained(i8** %[[V10]])
+// ARM64: %[[V12:.*]] = call i8* @llvm.objc.storeWeak(i8** %[[V7]], i8* %[[V11]])
+// ARM64: call void @llvm.objc.destroyWeak(i8** %[[V10]])
+// ARM64: call void @llvm.objc.release(i8* %[[V11]])
 
 void test_move_assignment_Weak(Weak *p) {
   *p = getWeak();
 }
 
 // COMMON: define void @test_parameter_Weak(%[[STRUCT_WEAK]]* %[[A:.*]])
 // COMMON: %[[V0:.*]] = bitcast %[[STRUCT_WEAK]]* %[[A]] to i8**
 // COMMON: call void @__destructor_{{.*}}(i8** %[[V0]])

test/CodeGenObjCXX/arc-attrs.mm

void sanityTest() {
   // CHECK-NEXT: [[OBJ1:%.*]] = call i8* @_Z11makeObject1v()
   // CHECK-NEXT: store i8* [[OBJ1]], i8** [[X]], align 8
   id x = makeObject1();
 
   // CHECK-NEXT: [[OBJ2:%.*]] = call i8* @_Z11makeObject2v()
   // CHECK-NEXT: call void @_Z13releaseObjectP11objc_object(i8* [[OBJ2]])
   releaseObject(makeObject2());
 
-  // CHECK-NEXT: call void @objc_storeStrong(i8** [[X]], i8* null)
+  // CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* null)
   // CHECK-NEXT: ret void
 }
 
 
 template <typename T>
 T makeObjectT1() __attribute__((ns_returns_retained));
 template <typename T>
 T makeObjectT2() __attribute__((ns_returns_retained));
void templateTest() {
   // CHECK-NEXT: [[OBJ2:%.*]] = call i8* @_Z12makeObjectT2IU8__strongP11objc_objectET_v()
   // CHECK-NEXT: call void @_Z13releaseObjectP11objc_object(i8* [[OBJ2]])
   releaseObject(makeObjectT2<id>());
 
   // CHECK-NEXT: [[OBJ3:%.*]] = call i8* @_Z11makeObject1v()
   // CHECK-NEXT: call void @_Z14releaseObjectTIU8__strongP11objc_objectEvT_(i8* [[OBJ3]])
   releaseObjectT(makeObject1());
 
-  // CHECK-NEXT: call void @objc_storeStrong(i8** [[X]], i8* null)
+  // CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* null)
   // CHECK-NEXT: ret void
 }
 
 // PR27887
 struct ForwardConsumed {
   ForwardConsumed(__attribute__((ns_consumed)) id x);
 };
 
 ForwardConsumed::ForwardConsumed(__attribute__((ns_consumed)) id x) {}
 
 // CHECK: define void @_ZN15ForwardConsumedC2EP11objc_object(
 // CHECK-NOT:  objc_retain
 // CHECK:      store i8* {{.*}}, i8** [[X:%.*]],
 // CHECK-NOT:  [[X]]
-// CHECK:      call void @objc_storeStrong(i8** [[X]], i8* null)
+// CHECK:      call void @llvm.objc.storeStrong(i8** [[X]], i8* null)
 
 // CHECK: define void @_ZN15ForwardConsumedC1EP11objc_object(
 // CHECK-NOT:  objc_retain
 // CHECK:      store i8* {{.*}}, i8** [[X:%.*]],
 // CHECK:      [[T0:%.*]] = load i8*, i8** [[X]],
 // CHECK-NEXT: store i8* null, i8** [[X]],
 // CHECK-NEXT: call void @_ZN15ForwardConsumedC2EP11objc_object({{.*}}, i8* [[T0]])
-// CHECK:      call void @objc_storeStrong(i8** [[X]], i8* null)
+// CHECK:      call void @llvm.objc.storeStrong(i8** [[X]], i8* null)

test/CodeGenObjCXX/arc-blocks.mm

 // CHECK-LABEL: define linkonce_odr hidden void @__copy_helper_block_ea8_32s40r48w56c15_ZTSN5test12S0E60c15_ZTSN5test12S0E(
 // CHECK: %[[BLOCK_SOURCE:.*]] = bitcast i8* %{{.*}} to <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>*
 // CHECK: %[[BLOCK_DEST:.*]] = bitcast i8* %{{.*}} to <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>*
 
 // CHECK: %[[V9:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_SOURCE]], i32 0, i32 5
 // CHECK: %[[V10:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_DEST]], i32 0, i32 5
 // CHECK: %[[BLOCKCOPY_SRC2:.*]] = load i8*, i8** %[[V9]], align 8
 // CHECK: store i8* null, i8** %[[V10]], align 8
-// CHECK: call void @objc_storeStrong(i8** %[[V10]], i8* %[[BLOCKCOPY_SRC2]])
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V10]], i8* %[[BLOCKCOPY_SRC2]])
 
 // CHECK: %[[V4:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_SOURCE]], i32 0, i32 6
 // CHECK: %[[V5:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_DEST]], i32 0, i32 6
 // CHECK: %[[BLOCKCOPY_SRC:.*]] = load i8*, i8** %[[V4]], align 8
 // CHECK: %[[V6:.*]] = bitcast i8** %[[V5]] to i8*
 // CHECK: call void @_Block_object_assign(i8* %[[V6]], i8* %[[BLOCKCOPY_SRC]], i32 8)
 
 // CHECK: %[[V7:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_SOURCE]], i32 0, i32 7
 // CHECK: %[[V8:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_DEST]], i32 0, i32 7
-// CHECK: call void @objc_copyWeak(i8** %[[V8]], i8** %[[V7]])
+// CHECK: call void @llvm.objc.copyWeak(i8** %[[V8]], i8** %[[V7]])
 
 // CHECK: %[[V11:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_SOURCE]], i32 0, i32 8
 // CHECK: %[[V12:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_DEST]], i32 0, i32 8
 // CHECK: invoke void @_ZN5test12S0C1ERKS0_(%[[STRUCT_TEST1_S0]]* %[[V12]], %[[STRUCT_TEST1_S0]]* dereferenceable(4) %[[V11]])
 // CHECK: to label %[[INVOKE_CONT:.*]] unwind label %[[LPAD:.*]]
 
 // CHECK: [[INVOKE_CONT]]:
 // CHECK: %[[V13:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK_SOURCE]], i32 0, i32 9

 // CHECK: [[LPAD3]]:
 // CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V12]])
 // CHECK: to label %[[INVOKE_CONT5:.*]] unwind label %[[TERMINATE_LPAD:.*]]
 
 // CHECK: [[INVOKE_CONT5]]:
 // CHECK: br label %[[EHCLEANUP]]
 
 // CHECK: [[EHCLEANUP]]:
-// CHECK: call void @objc_destroyWeak(i8** %[[V8]])
+// CHECK: call void @llvm.objc.destroyWeak(i8** %[[V8]])
 // CHECK: %[[V21:.*]] = load i8*, i8** %[[V5]], align 8
 // CHECK: call void @_Block_object_dispose(i8* %[[V21]], i32 8)
-// CHECK: call void @objc_storeStrong(i8** %[[V10]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V10]], i8* null)
 // CHECK: br label %[[EH_RESUME:.*]]
 
 // CHECK: [[EH_RESUME]]:
 // CHECK: resume { i8*, i32 }
 
 // CHECK: [[TERMINATE_LPAD]]:
 // CHECK: call void @__clang_call_terminate(
 
 // CHECK-O1-LABEL: define linkonce_odr hidden void @__copy_helper_block_ea8_32s40r48w56c15_ZTSN5test12S0E60c15_ZTSN5test12S0E(
-// CHECK-O1: tail call void @objc_release({{.*}}) {{.*}} !clang.imprecise_release
+// CHECK-O1: tail call void @llvm.objc.release({{.*}}) {{.*}} !clang.imprecise_release
 // CHECK-NOEXCP: define linkonce_odr hidden void @__copy_helper_block_8_32s40r48w56c15_ZTSN5test12S0E60c15_ZTSN5test12S0E(
 
 // CHECK: define linkonce_odr hidden void @__destroy_helper_block_ea8_32s40r48w56c15_ZTSN5test12S0E60c15_ZTSN5test12S0E(
 // CHECK: %[[BLOCK:.*]] = bitcast i8* %{{.*}} to <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>*
 // CHECK: %[[V4:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK]], i32 0, i32 5
 // CHECK: %[[V2:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK]], i32 0, i32 6
 // CHECK: %[[V3:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK]], i32 0, i32 7
 // CHECK: %[[V5:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK]], i32 0, i32 8
 // CHECK: %[[V6:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]], %[[STRUCT_TRIVIAL_INTERNAL]] }>* %[[BLOCK]], i32 0, i32 9
 // CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V6]])
 // CHECK: to label %[[INVOKE_CONT:.*]] unwind label %[[LPAD:.*]]
 
 // CHECK: [[INVOKE_CONT]]:
 // CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V5]])
 // CHECK: to label %[[INVOKE_CONT2:.*]] unwind label %[[LPAD1:.*]]
 
 // CHECK: [[INVOKE_CONT2]]:
-// CHECK: call void @objc_destroyWeak(i8** %[[V3]])
+// CHECK: call void @llvm.objc.destroyWeak(i8** %[[V3]])
 // CHECK: %[[V7:.*]] = load i8*, i8** %[[V2]], align 8
 // CHECK: call void @_Block_object_dispose(i8* %[[V7]], i32 8)
-// CHECK: call void @objc_storeStrong(i8** %[[V4]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V4]], i8* null)
 // CHECK: ret void
 
 // CHECK: [[LPAD]]:
 // CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V5]])
 // CHECK: to label %[[INVOKE_CONT3:.*]] unwind label %[[TERMINATE_LPAD:.*]]
 
 // CHECK: [[LPAD1]]
 // CHECK: br label %[[EHCLEANUP:.*]]
 
 // CHECK: [[INVOKE_CONT3]]:
 // CHECK: br label %[[EHCLEANUP]]
 
 // CHECK: [[EHCLEANUP]]:
-// CHECK: call void @objc_destroyWeak(i8** %[[V3]])
+// CHECK: call void @llvm.objc.destroyWeak(i8** %[[V3]])
 // CHECK: %[[V14:.*]] = load i8*, i8** %[[V2]], align 8
 // CHECK: call void @_Block_object_dispose(i8* %[[V14]], i32 8)
-// CHECK: call void @objc_storeStrong(i8** %[[V4]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V4]], i8* null)
 // CHECK: br label %[[EH_RESUME:.*]]
 
 // CHECK: [[EH_RESUME]]:
 // CHECK: resume { i8*, i32 }
 
 // CHECK: [[TERMINATE_LPAD]]:
 // CHECK: call void @__clang_call_terminate(
 
 // CHECK-O1-LABEL: define linkonce_odr hidden void @__destroy_helper_block_ea8_32s40r48w56c15_ZTSN5test12S0E60c15_ZTSN5test12S0E(
-// CHECK-O1: tail call void @objc_release({{.*}}) {{.*}} !clang.imprecise_release
-// CHECK-O1: tail call void @objc_release({{.*}}) {{.*}} !clang.imprecise_release
+// CHECK-O1: tail call void @llvm.objc.release({{.*}}) {{.*}} !clang.imprecise_release
+// CHECK-O1: tail call void @llvm.objc.release({{.*}}) {{.*}} !clang.imprecise_release
 // CHECK-NOEXCP: define linkonce_odr hidden void @__destroy_helper_block_8_32s40r48w56c15_ZTSN5test12S0E60c15_ZTSN5test12S0E(
 
 namespace {
 struct TrivialInternal {
   int a;
 };
 }
 

test/CodeGenObjCXX/arc-constexpr.mm

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -fobjc-runtime-has-weak -o - -std=c++11 %s | FileCheck %s
 
 // CHECK: %[[TYPE:[a-z0-9]+]] = type opaque
 // CHECK: @[[CFSTRING:[a-z0-9_]+]] = private global %struct.__NSConstantString_tag
 @class NSString;
 
 // CHECK-LABEL: define void @_Z5test1v
 // CHECK:   %[[ALLOCA:[A-Z]+]] = alloca %[[TYPE]]*
-// CHECK:   %[[V0:[0-9]+]] = call i8* @objc_retain(i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
+// CHECK:   %[[V0:[0-9]+]] = call i8* @llvm.objc.retain(i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
 // CHECK:   %[[V1:[0-9]+]] = bitcast i8* %[[V0]] to %[[TYPE]]*
 // CHECK:   store %[[TYPE]]* %[[V1]], %[[TYPE]]** %[[ALLOCA]]
 // CHECK:   %[[V2:[0-9]+]] = bitcast %[[TYPE]]** %[[ALLOCA]]
-// CHECK:   call void @objc_storeStrong(i8** %[[V2]], i8* null)
+// CHECK:   call void @llvm.objc.storeStrong(i8** %[[V2]], i8* null)
 void test1() {
   constexpr NSString *S = @"abc";
 }
 
 // CHECK-LABEL: define void @_Z5test2v
 // CHECK:      %[[CONST:[a-zA-Z]+]] = alloca %[[TYPE]]*
 // CHECK:      %[[REF_CONST:[a-zA-Z]+]] = alloca %[[TYPE]]*
-// CHECK:      %[[V0:[0-9]+]] = call i8* @objc_retain(i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
+// CHECK:      %[[V0:[0-9]+]] = call i8* @llvm.objc.retain(i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
 // CHECK-NEXT: %[[V1:[0-9]+]] = bitcast i8* %[[V0]] to %[[TYPE]]*
 // CHECK-NEXT: store %[[TYPE]]* %[[V1]], %[[TYPE]]** %[[CONST]]
-// CHECK:      %[[V2:[0-9]+]] = call i8* @objc_retain(i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
+// CHECK:      %[[V2:[0-9]+]] = call i8* @llvm.objc.retain(i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
 // CHECK-NEXT: %[[V3:[0-9]+]] = bitcast i8* %[[V2]] to %[[TYPE]]*
 // CHECK-NEXT: store %[[TYPE]]* %[[V3]], %[[TYPE]]** %[[REF_CONST]]
 // CHECK:      %[[V4:[0-9]+]] = bitcast %[[TYPE]]** %[[REF_CONST]]
-// CHECK-NEXT: call void @objc_storeStrong(i8** %[[V4]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** %[[V4]], i8* null)
 // CHECK:      %[[V5:[0-9]+]] = bitcast %[[TYPE]]** %[[CONST]]
-// CHECK-NEXT: call void @objc_storeStrong(i8** %[[V5]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** %[[V5]], i8* null)
 void test2() {
   constexpr NSString *Const = @"abc";
   // In IR RefConst should be initialized with Const initializer instead of
   // reading from variable.
   NSString* RefConst = Const;
 }
 
 // CHECK-LABEL: define void @_Z5test3v
 // CHECK:      %[[WEAK_CONST:[a-zA-Z]+]] = alloca %[[TYPE]]*
 // CHECK:      %[[REF_WEAK_CONST:[a-zA-Z]+]] = alloca %[[TYPE]]*
 // CHECK:      %[[V0:[0-9]+]] = bitcast %[[TYPE]]** %[[WEAK_CONST]]
-// CHECK-NEXT: %[[V1:[0-9]+]] = call i8* @objc_initWeak(i8** %[[V0]], i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
+// CHECK-NEXT: %[[V1:[0-9]+]] = call i8* @llvm.objc.initWeak(i8** %[[V0]], i8* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]]
 // CHECK:      store %[[TYPE]]* bitcast (%struct.__NSConstantString_tag* @[[CFSTRING]] to %[[TYPE]]*), %[[TYPE]]** %[[REF_WEAK_CONST]]
 // CHECK:      %[[V2:[0-9]+]] = bitcast %[[TYPE]]** %[[REF_WEAK_CONST]]
-// CHECK-NEXT: call void @objc_storeStrong(i8** %[[V2]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** %[[V2]], i8* null)
 // CHECK:      %[[V3:[0-9]+]] = bitcast %[[TYPE]]** %[[WEAK_CONST]]
-// CHECK-NEXT: call void @objc_destroyWeak(i8** %[[V3]])
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** %[[V3]])
 void test3() {
   __weak constexpr NSString *WeakConst = @"abc";
   NSString* RefWeakConst = WeakConst;
 }

test/CodeGenObjCXX/arc-cxx11-init-list.mm

 
 void function(std::initializer_list<I *>);
 
 extern "C" void single() { function({ [I new] }); }
 
 // CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}})
 // CHECK-NEXT: [[CAST:%.*]] = bitcast [{{[0-9]+}} x %0*]* %{{.*}} to i8**
 // CHECK-NEXT: store i8* [[INSTANCE]], i8** [[CAST]],
-// CHECK: call void @objc_release(i8* {{.*}})
+// CHECK: call void @llvm.objc.release(i8* {{.*}})
 
 extern "C" void multiple() { function({ [I new], [I new] }); }
 
 // CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}})
 // CHECK-NEXT: [[CAST:%.*]] = bitcast [{{[0-9]+}} x %0*]* %{{.*}} to i8**
 // CHECK-NEXT: store i8* [[INSTANCE]], i8** [[CAST]],
-// CHECK: call void @objc_release(i8* {{.*}})
+// CHECK: call void @llvm.objc.release(i8* {{.*}})
 
 std::initializer_list<id> foo1() {
   return {@"str0", @"str1"};
 }
 
 // CHECK: define void @_Z4foo1v(%"class.std::initializer_list.0"* {{.*}} %[[AGG_RESULT:.*]])
 // CHECK: %[[BEGIN:.*]] = getelementptr inbounds %"class.std::initializer_list.0", %"class.std::initializer_list.0"* %[[AGG_RESULT]], i32 0, i32 0
 // CHECK: store i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @[[REFTMP]], i32 0, i32 0), i8*** %[[BEGIN]]
 // CHECK: %[[SIZE:.*]] = getelementptr inbounds %"class.std::initializer_list.0", %"class.std::initializer_list.0"* %[[AGG_RESULT]], i32 0, i32 1
 // CHECK: store i32 2, i32* %[[SIZE]]
 // CHECK: ret void
 
 void external();
 
 extern "C" void extended() {
   const auto && temporary = { [I new] };
   external();
 }
 
 // CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}})
 // CHECK: {{.*}} call void @_Z8externalv()
-// CHECK: {{.*}} call void @objc_release(i8* {{.*}})
+// CHECK: {{.*}} call void @llvm.objc.release(i8* {{.*}})
 
 std::initializer_list<I *> il = { [I new] };
 
-// CHECK: [[POOL:%.*]] = {{.*}} call i8* @objc_autoreleasePoolPush()
+// CHECK: [[POOL:%.*]] = {{.*}} call i8* @llvm.objc.autoreleasePoolPush()
 // CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}})
 // CHECK-NEXT: store i8* [[INSTANCE]], i8** bitcast ([1 x %0*]* @_ZGR2il_ to i8**)
-// CHECK: {{.*}} call void @objc_autoreleasePoolPop(i8* [[POOL]])
+// CHECK: {{.*}} call void @llvm.objc.autoreleasePoolPop(i8* [[POOL]])

test/CodeGenObjCXX/arc-exceptions.mm

void test0(void) {
   }
 }
 // CHECK-LABEL: define void @_Z5test0v()
 // CHECK:      [[E:%.*]] = alloca [[ETY:%.*]]*, align 8
 // CHECK-NEXT: invoke void @_Z12test0_helperv()
 // CHECK:      [[T0:%.*]] = call i8* @objc_begin_catch(
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[ETY]]*
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[ETY]]* [[T1]] to i8*
-// CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retain(i8* [[T2]]) [[NUW:#[0-9]+]]
+// CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.retain(i8* [[T2]]) [[NUW:#[0-9]+]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to [[ETY]]*
 // CHECK-NEXT: store [[ETY]]* [[T4]], [[ETY]]** [[E]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[ETY]]** [[E]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null) [[NUW]]
 // CHECK-NEXT: call void @objc_end_catch() [[NUW]]
 
 void test1_helper(void);
 void test1(void) {
   @try {
     test1_helper();
   } @catch (__weak Ety *e) {
   }
 }
 // CHECK-LABEL: define void @_Z5test1v()
 // CHECK:      [[E:%.*]] = alloca [[ETY:%.*]]*, align 8
 // CHECK-NEXT: invoke void @_Z12test1_helperv()
 // CHECK:      [[T0:%.*]] = call i8* @objc_begin_catch(
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[ETY]]*
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[ETY]]** [[E]] to i8**
 // CHECK-NEXT: [[T3:%.*]] = bitcast [[ETY]]* [[T1]] to i8*
-// CHECK-NEXT: call i8* @objc_initWeak(i8** [[T2]], i8* [[T3]]) [[NUW]]
+// CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[T2]], i8* [[T3]]) [[NUW]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[ETY]]** [[E]] to i8**
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[T0]]) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[T0]]) [[NUW]]
 // CHECK-NEXT: call void @objc_end_catch() [[NUW]]
 
 void test2_helper(void);
 void test2(void) {
   try {
     test2_helper();
   } catch (Ety *e) {
   }
 }
 // CHECK-LABEL: define void @_Z5test2v()
 // CHECK:      [[E:%.*]] = alloca [[ETY:%.*]]*, align 8
 // CHECK-NEXT: invoke void @_Z12test2_helperv()
 // CHECK:      [[T0:%.*]] = call i8* @__cxa_begin_catch(
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[ETY]]*
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[ETY]]* [[T1]] to i8*
-// CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retain(i8* [[T2]]) [[NUW]]
+// CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.retain(i8* [[T2]]) [[NUW]]
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to [[ETY]]*
 // CHECK-NEXT: store [[ETY]]* [[T4]], [[ETY]]** [[E]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[ETY]]** [[E]] to i8**
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[T0]], i8* null) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[T0]], i8* null) [[NUW]]
 // CHECK-NEXT: call void @__cxa_end_catch() [[NUW]]
 
 void test3_helper(void);
 void test3(void) {
   try {
     test3_helper();
   } catch (Ety * __weak e) {
   }
 }
 // CHECK-LABEL: define void @_Z5test3v()
 // CHECK:      [[E:%.*]] = alloca [[ETY:%.*]]*, align 8
 // CHECK-NEXT: invoke void @_Z12test3_helperv()
 // CHECK:      [[T0:%.*]] = call i8* @__cxa_begin_catch(
 // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[ETY]]*
 // CHECK-NEXT: [[T2:%.*]] = bitcast [[ETY]]** [[E]] to i8**
 // CHECK-NEXT: [[T3:%.*]] = bitcast [[ETY]]* [[T1]] to i8*
-// CHECK-NEXT: call i8* @objc_initWeak(i8** [[T2]], i8* [[T3]]) [[NUW]]
+// CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[T2]], i8* [[T3]]) [[NUW]]
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[ETY]]** [[E]] to i8**
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[T0]]) [[NUW]]
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[T0]]) [[NUW]]
 // CHECK-NEXT: call void @__cxa_end_catch() [[NUW]]
 
 namespace test4 {
   struct A {
     id single;
     id array[2][3];
 
     A();
namespace test4 {
   //   Landing pad from throw site:
   // CHECK:      landingpad
   //     - First, destroy all of array.
   // CHECK:      [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x i8*]], [2 x [3 x i8*]]* [[ARRAY]], i32 0, i32 0, i32 0
   // CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds i8*, i8** [[ARRAYBEGIN]], i64 6
   // CHECK-NEXT: br label
   // CHECK:      [[AFTER:%.*]] = phi i8** [ [[ARRAYEND]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
   // CHECK-NEXT: [[ELT]] = getelementptr inbounds i8*, i8** [[AFTER]], i64 -1
-  // CHECK-NEXT: call void @objc_storeStrong(i8** [[ELT]], i8* null) [[NUW]]
+  // CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[ELT]], i8* null) [[NUW]]
   // CHECK-NEXT: [[DONE:%.*]] = icmp eq i8** [[ELT]], [[ARRAYBEGIN]]
   // CHECK-NEXT: br i1 [[DONE]],
   //     - Next, destroy single.
-  // CHECK:      call void @objc_storeStrong(i8** [[SINGLE]], i8* null) [[NUW]]
+  // CHECK:      call void @llvm.objc.storeStrong(i8** [[SINGLE]], i8* null) [[NUW]]
   // CHECK:      br label
   // CHECK:      resume
 }
 
 // rdar://21397946
 __attribute__((ns_returns_retained)) id test5_helper(unsigned);
 void test5(void) {
   id array[][2] = {

test/CodeGenObjCXX/arc-forwarded-lambda-call.mm

 // RUN: %clang_cc1 -triple x86_64-apple-macosx10.12.0 -emit-llvm -disable-llvm-passes -O3 -fblocks -fobjc-arc -fobjc-runtime-has-weak -std=c++11 -o - %s | FileCheck %s
 
 void test0(id x) {
   extern void test0_helper(id (^)(void));
   test0_helper([=]() { return x; });
   // CHECK-LABEL: define internal i8* @___Z5test0P11objc_object_block_invoke
   // CHECK: [[T0:%.*]] = call i8* @"_ZZ5test0P11objc_objectENK3$_0clEv"
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
-  // CHECK-NEXT: [[T2:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T2:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T1]])
   // CHECK-NEXT: ret i8* [[T2]]
 }
 
 // Check that the delegating block invoke function doesn't destruct the Weak
 // object that is passed.
 
 // CHECK-LABEL: define internal void @___Z8testWeakv_block_invoke(
 // CHECK: call void @"_ZZ8testWeakvENK3$_2clE4Weak"(
 // CHECK-NEXT: ret void
 
 // CHECK-LABEL: define internal void @"_ZZ8testWeakvENK3$_2clE4Weak"(
 // CHECK: call void @_ZN4WeakD1Ev(
 // CHECK-NEXT: ret void
 
 id test1_rv;
 
 void test1() {
   extern void test1_helper(id (*)(void));
   test1_helper([](){ return test1_rv; });
   // CHECK-LABEL: define internal i8* @"_ZZ5test1vEN3$_18__invokeEv"
   // CHECK: [[T0:%.*]] = call i8* @"_ZZ5test1vENK3$_1clEv"
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
-  // CHECK-NEXT: [[T2:%.*]] = tail call i8* @objc_autoreleaseReturnValue(i8* [[T1]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T2:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T1]])
   // CHECK-NEXT: ret i8* [[T2]]
 }
 
 struct Weak {
   __weak id x;
 };
 
 void testWeak() {
   extern void testWeak_helper(void (^)(Weak));
   testWeak_helper([](Weak){});
 }

test/CodeGenObjCXX/arc-globals.mm

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -O2 -disable-llvm-passes -o - %s | FileCheck %s
 
 // Test that we're properly retaining lifetime-qualified pointers
 // initialized statically and wrapping up those initialization in an
 // autorelease pool.
 id getObject();
 
 // CHECK-LABEL: define internal void @__cxx_global_var_init
 // CHECK: call i8* @_Z9getObjectv
-// CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
+// CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
 // CHECK-NEXT: {{store i8*.*@global_obj}}
 // CHECK-NEXT: ret void
 id global_obj = getObject();
 
 // CHECK-LABEL: define internal void @__cxx_global_var_init
 // CHECK: call i8* @_Z9getObjectv
-// CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
+// CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
 // CHECK-NEXT: {{store i8*.*@global_obj2}}
 // CHECK-NEXT: ret void
 id global_obj2 = getObject();
 
 // CHECK-LABEL: define internal void @_GLOBAL__sub_I_arc_globals.mm
-// CHECK: call i8* @objc_autoreleasePoolPush()
+// CHECK: call i8* @llvm.objc.autoreleasePoolPush()
 // CHECK-NEXT: call void @__cxx_global_var_init
 // CHECK-NEXT: call void @__cxx_global_var_init.1
-// CHECK-NEXT: call void @objc_autoreleasePoolPop(
+// CHECK-NEXT: call void @llvm.objc.autoreleasePoolPop(
 // CHECK-NEXT: ret void

test/CodeGenObjCXX/arc-indirect.mm

 - (void)object:(id)obj struct:(S)s {
 }
 @end
 
 // CHECK-GNUSTEP: define internal void @_i_C__object_struct_(<{ %0*, i8*, i8*, %struct.S, [3 x i8] }>* inalloca)
 // CHECK-DARWIN: define internal void @"\01-[C object:struct:]"(<{ %0*, i8*, i8*, %struct.S, [3 x i8] }>* inalloca)
 // CHECK: %obj = getelementptr inbounds <{ %0*, i8*, i8*, %struct.S, [3 x i8] }>, <{ %0*, i8*, i8*, %struct.S, [3 x i8] }>* %0, i32 0, i32 2
 // CHECK: %[[INSTANCE:[0-9]+]] = load i8*, i8** %obj, align 4
-// CHECK: call void @objc_storeStrong(i8** %obj, i8* %[[INSTANCE]])
+// CHECK: call void @llvm.objc.storeStrong(i8** %obj, i8* %[[INSTANCE]])

test/CodeGenObjCXX/arc-move.mm

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -O2 -std=c++11 -disable-llvm-passes -o - %s | FileCheck %s
 
 // define void @_Z11simple_moveRU8__strongP11objc_objectS2_
 void simple_move(__strong id &x, __strong id &y) {
   // CHECK: = load i8*, i8**
   // CHECK: store i8* null
   // CHECK: = load i8*, i8**
   // CHECK: store i8*
-  // CHECK-NEXT: call void @objc_release
+  // CHECK-NEXT: call void @llvm.objc.release
   x = static_cast<__strong id&&>(y);
   // CHECK-NEXT: ret void
 }
 
 template<typename T>
 struct remove_reference {
   typedef T type;
 };

 // CHECK-LABEL: define void @_Z12library_moveRU8__strongP11objc_objectS2_
 void library_move(__strong id &x, __strong id &y) {
   // CHECK: call dereferenceable({{[0-9]+}}) i8** @_Z4moveIRU8__strongP11objc_objectEON16remove_referenceIT_E4typeEOS5_
   // CHECK: load i8*, i8**
   // CHECK: store i8* null, i8**
   // CHECK: load i8**, i8***
   // CHECK-NEXT: load i8*, i8**
   // CHECK-NEXT: store i8*
-  // CHECK-NEXT: call void @objc_release
+  // CHECK-NEXT: call void @llvm.objc.release
   // CHECK-NEXT: ret void
   x = move(y);
 }
 
 // CHECK-LABEL: define void @_Z12library_moveRU8__strongP11objc_object
 void library_move(__strong id &y) {
   // CHECK: [[X:%.*]] = alloca i8*, align 8
   // CHECK: [[I:%.*]] = alloca i32, align 4
void library_move(__strong id &y) {
 
   // CHECK-NEXT: [[IPTR1:%.*]] = bitcast i32* [[I]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* [[IPTR1]])
   // CHECK-NEXT: store i32 17
   int i = 17;
   // CHECK-NEXT: [[IPTR2:%.*]] = bitcast i32* [[I]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* [[IPTR2]])
   // CHECK-NEXT: [[OBJ:%[a-zA-Z0-9]+]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: call void @objc_release(i8* [[OBJ]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[OBJ]])
   // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @_Z10const_moveRU8__strongKP11objc_object(
 void const_move(const __strong id &x) {
   // CHECK:      [[Y:%.*]] = alloca i8*,
   // CHECK:      [[X:%.*]] = call dereferenceable({{[0-9]+}}) i8** @_Z4moveIRU8__strongKP11objc_objectEON16remove_referenceIT_E4typeEOS5_(
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   // CHECK-NEXT: store i8* [[T1]], i8** [[Y]]
   // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T0]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
   id y = move(x);
 }

test/CodeGenObjCXX/arc-new-delete.mm

 // RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -fblocks -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK -check-prefix=UNOPT
 // RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -fblocks -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -O -disable-llvm-passes | FileCheck %s -check-prefix=CHECK -check-prefix=OPT
 
 typedef __strong id strong_id;
 typedef __weak id weak_id;
 
 // CHECK-LABEL: define void @_Z8test_newP11objc_object
 void test_new(id invalue) {
   // CHECK: [[INVALUEADDR:%.*]] = alloca i8*
   // UNOPT-NEXT: store i8* null, i8** [[INVALUEADDR]]
-  // UNOPT-NEXT: call void @objc_storeStrong(i8** [[INVALUEADDR]], i8* [[INVALUE:%.*]])
-  // OPT-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* [[INVALUE:%.*]])
+  // UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[INVALUEADDR]], i8* [[INVALUE:%.*]])
+  // OPT-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* [[INVALUE:%.*]])
   // OPT-NEXT: store i8* [[T0]], i8** [[INVALUEADDR]]
 
   // CHECK: call i8* @_Znwm
   // CHECK-NEXT: {{bitcast i8\*.*to i8\*\*}}
   // CHECK-NEXT: store i8* null, i8**
   new strong_id;
   // CHECK: call i8* @_Znwm
   // CHECK-NEXT: {{bitcast i8\*.*to i8\*\*}}
   // UNOPT-NEXT: store i8* null, i8**
-  // OPT-NEXT: call i8* @objc_initWeak(i8** {{.*}}, i8* null)
+  // OPT-NEXT: call i8* @llvm.objc.initWeak(i8** {{.*}}, i8* null)
   new weak_id;
 
   // CHECK: call i8* @_Znwm
   // CHECK-NEXT: {{bitcast i8\*.*to i8\*\*}}
   // CHECK-NEXT: store i8* null, i8**
   new __strong id;
   // CHECK: call i8* @_Znwm
   // CHECK-NEXT: {{bitcast i8\*.*to i8\*\*}}
   // UNOPT-NEXT: store i8* null, i8**
-  // OPT-NEXT: call i8* @objc_initWeak(i8** {{.*}}, i8* null)
+  // OPT-NEXT: call i8* @llvm.objc.initWeak(i8** {{.*}}, i8* null)
   new __weak id;
 
   // CHECK: call i8* @_Znwm
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   // CHECK: store i8*
   new __strong id(invalue);
 
   // CHECK: call i8* @_Znwm
-  // CHECK: call i8* @objc_initWeak
+  // CHECK: call i8* @llvm.objc.initWeak
   new __weak id(invalue);
 
-  // UNOPT: call void @objc_storeStrong
-  // OPT: call void @objc_release
+  // UNOPT: call void @llvm.objc.storeStrong
+  // OPT: call void @llvm.objc.release
   // CHECK: ret void
 }
 
 // CHECK-LABEL: define void @_Z14test_array_new
 void test_array_new() {
   // CHECK: call i8* @_Znam
   // CHECK: store i64 17, i64*
   // CHECK: call void @llvm.memset.p0i8.i64
   new strong_id[17];
 
   // CHECK: call i8* @_Znam
   // CHECK: store i64 17, i64*
   // CHECK: call void @llvm.memset.p0i8.i64
   new weak_id[17];
   // CHECK: ret void
 }
 
 // CHECK-LABEL: define void @_Z11test_deletePU8__strongP11objc_objectPU6__weakS0_
 void test_delete(__strong id *sptr, __weak id *wptr) {
   // CHECK: br i1
-  // UNOPT: call void @objc_storeStrong(i8** {{.*}}, i8* null)
+  // UNOPT: call void @llvm.objc.storeStrong(i8** {{.*}}, i8* null)
   // OPT: load i8*, i8**
-  // OPT-NEXT: call void @objc_release
+  // OPT-NEXT: call void @llvm.objc.release
   // CHECK: call void @_ZdlPv
   delete sptr;
 
-  // CHECK: call void @objc_destroyWeak
+  // CHECK: call void @llvm.objc.destroyWeak
   // CHECK: call void @_ZdlPv
   delete wptr;
 
   // CHECK: ret void
 }
 
 // CHECK-LABEL: define void @_Z17test_array_deletePU8__strongP11objc_objectPU6__weakS0_
 void test_array_delete(__strong id *sptr, __weak id *wptr) {
   // CHECK: icmp eq i8** [[BEGIN:%.*]], null
   // CHECK: [[LEN:%.*]] = load i64, i64* {{%.*}}
   // CHECK: [[END:%.*]] = getelementptr inbounds i8*, i8** [[BEGIN]], i64 [[LEN]]
   // CHECK-NEXT: icmp eq i8** [[BEGIN]], [[END]]
   // CHECK: [[PAST:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]],
   // CHECK-NEXT: [[CUR]] = getelementptr inbounds i8*, i8** [[PAST]], i64 -1
-  // UNOPT-NEXT: call void @objc_storeStrong(i8** [[CUR]], i8* null)
+  // UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[CUR]], i8* null)
   // OPT-NEXT: [[T0:%.*]] = load i8*, i8** [[CUR]]
-  // OPT-NEXT: objc_release(i8* [[T0]])
+  // OPT-NEXT: llvm.objc.release(i8* [[T0]])
   // CHECK-NEXT: icmp eq i8** [[CUR]], [[BEGIN]]
   // CHECK: call void @_ZdaPv
   delete [] sptr;
 
   // CHECK: icmp eq i8** [[BEGIN:%.*]], null
   // CHECK: [[LEN:%.*]] = load i64, i64* {{%.*}}
   // CHECK: [[END:%.*]] = getelementptr inbounds i8*, i8** [[BEGIN]], i64 [[LEN]]
   // CHECK-NEXT: icmp eq i8** [[BEGIN]], [[END]]
   // CHECK: [[PAST:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]],
   // CHECK-NEXT: [[CUR]] = getelementptr inbounds i8*, i8** [[PAST]], i64 -1
-  // CHECK-NEXT: call void @objc_destroyWeak(i8** [[CUR]])
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[CUR]])
   // CHECK-NEXT: icmp eq i8** [[CUR]], [[BEGIN]]
   // CHECK: call void @_ZdaPv
   delete [] wptr;
 }

test/CodeGenObjCXX/arc-pseudo-destructors.mm

 // RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -fblocks -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s | FileCheck %s
 
 // CHECK-LABEL: define void @_Z28test_objc_object_pseudo_dtorPU8__strongP11objc_objectPU6__weakS0_
 void test_objc_object_pseudo_dtor(__strong id *ptr, __weak id *wptr) {
   // CHECK: load i8**, i8***
   // CHECK-NEXT: load i8*, i8**
-  // CHECK-NEXT: call void @objc_release
+  // CHECK-NEXT: call void @llvm.objc.release
   ptr->~id();
 
-  // CHECK: call void @objc_destroyWeak(i8** {{%.*}})
+  // CHECK: call void @llvm.objc.destroyWeak(i8** {{%.*}})
   wptr->~id();
 
   // CHECK: load i8**, i8***
   // CHECK-NEXT: load i8*, i8**
-  // CHECK-NEXT: call void @objc_release
+  // CHECK-NEXT: call void @llvm.objc.release
   (*ptr).~id();
 
-  // CHECK: call void @objc_destroyWeak(i8** {{%.*}})
+  // CHECK: call void @llvm.objc.destroyWeak(i8** {{%.*}})
   (*wptr).~id();
   // CHECK: ret void
 }

test/CodeGenObjCXX/arc-references.mm

 // RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -O2 -disable-llvm-passes -o - %s | FileCheck %s
 
 @interface A
 @end
 
 id getObject();
 void callee();
 
 // Lifetime extension for binding a reference to an rvalue
 // CHECK-LABEL: define void @_Z5test0v()
 void test0() {
   // CHECK: call i8* @_Z9getObjectv
-  // CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
   const __strong id &ref1 = getObject();
   // CHECK: call void @_Z6calleev
   callee();
   // CHECK: call i8* @_Z9getObjectv
-  // CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
-  // CHECK-NEXT: call i8* @objc_autorelease
+  // CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
+  // CHECK-NEXT: call i8* @llvm.objc.autorelease
   const __autoreleasing id &ref2 = getObject();
   // CHECK: call void @_Z6calleev
   callee();
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: ret
 }
 
 // No lifetime extension when we're binding a reference to an lvalue.
 // CHECK-LABEL: define void @_Z5test1RU8__strongP11objc_objectRU6__weakS0_
 void test1(__strong id &x, __weak id &y) {
   // CHECK-NOT: release
   const __strong id &ref1 = x;
   const __autoreleasing id &ref2 = x;
   const __weak id &ref3 = y;
   // CHECK: ret void
 }
 
 typedef __strong id strong_id;
 
 //CHECK: define void @_Z5test3v
 void test3() {
   // CHECK: [[REF:%.*]] = alloca i8**, align 8
-  // CHECK: call i8* @objc_initWeak
+  // CHECK: call i8* @llvm.objc.initWeak
   // CHECK-NEXT: store i8**
   const __weak id &ref = strong_id();
   // CHECK-NEXT: call void @_Z6calleev()
   callee();
-  // CHECK-NEXT: call void @objc_destroyWeak
+  // CHECK-NEXT: call void @llvm.objc.destroyWeak
   // CHECK-NEXT: [[PTR:%.*]] = bitcast i8*** [[REF]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTR]])
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @_Z5test4RU8__strongP11objc_object
 void test4(__strong id &x) {
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   __strong A* const &ar = x;
   // CHECK: store i32 17, i32*
   int i = 17;
-  // CHECK: call void @objc_release(
+  // CHECK: call void @llvm.objc.release(
   // CHECK: ret void
 }
 
 void sink(__strong A* &&);
 
 // CHECK-LABEL: define void @_Z5test5RU8__strongP11objc_object
 void test5(__strong id &x) {
   // CHECK:      [[REFTMP:%.*]] = alloca {{%.*}}*, align 8
   // CHECK:      [[I:%.*]] = alloca i32, align 4
-  // CHECK:      [[OBJ_ID:%.*]] = call i8* @objc_retain(
+  // CHECK:      [[OBJ_ID:%.*]] = call i8* @llvm.objc.retain(
   // CHECK-NEXT: [[OBJ_A:%.*]] = bitcast i8* [[OBJ_ID]] to [[A:%[a-zA-Z0-9]+]]*
   // CHECK-NEXT: store [[A]]* [[OBJ_A]], [[A]]** [[REFTMP:%[a-zA-Z0-9]+]]
   // CHECK-NEXT: call void @_Z4sinkOU8__strongP1A
   sink(x);  
   // CHECK-NEXT: [[OBJ_A:%[a-zA-Z0-9]+]] = load [[A]]*, [[A]]** [[REFTMP]]
   // CHECK-NEXT: [[OBJ_ID:%[a-zA-Z0-9]+]] = bitcast [[A]]* [[OBJ_A]] to i8*
-  // CHECK-NEXT: call void @objc_release
+  // CHECK-NEXT: call void @llvm.objc.release
   // CHECK-NEXT: [[IPTR1:%.*]] = bitcast i32* [[I]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* [[IPTR1]])
   // CHECK-NEXT: store i32 17, i32
   int i = 17;
   // CHECK-NEXT: [[IPTR2:%.*]] = bitcast i32* [[I]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* [[IPTR2]])
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define internal void @__cxx_global_var_init(
 // CHECK: call i8* @_Z9getObjectv
-// CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
+// CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
 const __strong id &global_ref = getObject();
 
 // Note: we intentionally don't release the object.
 

test/CodeGenObjCXX/arc-returns-inner-reference-ptr.mm

void foo() {
    Test58 *ptr;
    char *c = [(ptr) interior];
 
    int i = [(ptr) reference_to_interior_int];
 }
 
 // CHECK: [[T0:%.*]] = load {{%.*}} {{%.*}}, align 8
 // CHECK: [[T1:%.*]] = bitcast {{%.*}} [[T0]] to i8*
-// call i8* @objc_retainAutorelease(i8* [[T1]]) nounwind
+// call i8* @llvm.objc.retainAutorelease(i8* [[T1]]) nounwind
 // CHECK: [[T2:%.*]] = load {{%.*}} {{%.*}}, align 8
 // CHECK: [[T3:%.*]] = bitcast {{%.*}} [[T2]] to i8*
-// call i8* @objc_retainAutorelease(i8* [[T3]]) nounwind
+// call i8* @llvm.objc.retainAutorelease(i8* [[T3]]) nounwind
 

test/CodeGenObjCXX/arc-special-member-functions.mm

void test_ObjCMember_copy_assign(ObjCMember m1, ObjCMember m2) {
   m1 = m2;
   // CHECK-NEXT: call void @_ZN10ObjCMemberD1Ev(
   // CHECK-NEXT: call void @_ZN10ObjCMemberD1Ev(
   // CHECK-NEXT: ret void
 }
 
 // Implicitly-generated copy assignment operator for ObjCMember
 // CHECK:    {{define linkonce_odr.*@_ZN10ObjCMemberaSERKS_}}
-// CHECK:      call void @objc_storeStrong
+// CHECK:      call void @llvm.objc.storeStrong
 // CHECK:      ret
 
 // CHECK-LABEL: define void @_Z47test_ObjCArrayMember_default_construct_destructv
 void test_ObjCArrayMember_default_construct_destruct() {
   // CHECK: call void @_ZN15ObjCArrayMemberC1Ev
   ObjCArrayMember m1;
   // CHECK: call void @_ZN15ObjCArrayMemberD1Ev
   // CHECK: ret void
void test_ObjCArrayMember_copy_assign(ObjCArrayMember m1, ObjCArrayMember m2) {
   m1 = m2;
   // CHECK-NEXT: call void @_ZN15ObjCArrayMemberD1Ev(
   // CHECK-NEXT: call void @_ZN15ObjCArrayMemberD1Ev(
   // CHECK-NEXT: ret void
 }
 
 // Implicitly-generated copy assignment operator for ObjCArrayMember
 // CHECK: {{define linkonce_odr.*@_ZN15ObjCArrayMemberaSERKS_}}
-// CHECK:      call void @objc_storeStrong
+// CHECK:      call void @llvm.objc.storeStrong
 // CHECK-NEXT: br label
 // CHECK: ret
 
 // CHECK-LABEL: define void @_Z47test_ObjCBlockMember_default_construct_destructv
 void test_ObjCBlockMember_default_construct_destruct() {
   // CHECK: call void @_ZN15ObjCBlockMemberC1Ev
   ObjCBlockMember m;
   // CHECK-NEXT: call void @_ZN15ObjCBlockMemberD1Ev
void test_ObjCBlockMember_copy_assign(ObjCBlockMember m1, ObjCBlockMember m2) {
   // CHECK-NEXT: ret void
 }
 
 // Implicitly-generated copy assignment operator for ObjCBlockMember
 // CHECK:    define linkonce_odr dereferenceable({{[0-9]+}}) {{%.*}}* @_ZN15ObjCBlockMemberaSERKS_(
 // CHECK:      [[T0:%.*]] = getelementptr inbounds [[T:%.*]], [[T:%.*]]* {{%.*}}, i32 0, i32 0
 // CHECK-NEXT: [[T1:%.*]] = load i32 (i32)*, i32 (i32)** [[T0]], align 8
 // CHECK-NEXT: [[T2:%.*]] = bitcast i32 (i32)* [[T1]] to i8*
-// CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retainBlock(i8* [[T2]])
+// CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T2]])
 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to i32 (i32)*
 // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[T]], [[T]]* {{%.*}}, i32 0, i32 0
 // CHECK-NEXT: [[T6:%.*]] = load i32 (i32)*, i32 (i32)** [[T5]], align 8
 // CHECK-NEXT: store i32 (i32)* [[T4]], i32 (i32)** [[T5]]
 // CHECK-NEXT: [[T7:%.*]] = bitcast i32 (i32)* [[T6]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T7]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T7]])
 // CHECK-NEXT: ret
 
 // Check that the Weak object passed to this constructor is not destructed after
 // the delegate constructor is called.
 
 // CHECK: define linkonce_odr void @_ZN7DerivedCI24BaseE4Weak(
 // CHECK: call void @_ZN4BaseC2E4Weak(
 // CHECK-NEXT: ret void
 
 // Implicitly-generated default constructor for ObjCMember
 // CHECK-LABEL: define linkonce_odr void @_ZN10ObjCMemberC2Ev
 // CHECK-NOT: objc_release
 // CHECK: store i8* null
 // CHECK-NEXT: ret void
 
 // Implicitly-generated destructor for ObjCMember
 // CHECK-LABEL: define linkonce_odr void @_ZN10ObjCMemberD2Ev
-// CHECK: call void @objc_storeStrong
+// CHECK: call void @llvm.objc.storeStrong
 // CHECK: ret void
 
 // Implicitly-generated copy constructor for ObjCMember
 // CHECK-LABEL: define linkonce_odr void @_ZN10ObjCMemberC2ERKS_
 // CHECK-NOT: objc_release
-// CHECK: call i8* @objc_retain
+// CHECK: call i8* @llvm.objc.retain
 // CHECK-NEXT: store i8*
 // CHECK-NEXT: ret void
 
 // Implicitly-generated default constructor for ObjCArrayMember
 // CHECK-LABEL: define linkonce_odr void @_ZN15ObjCArrayMemberC2Ev
 // CHECK: call void @llvm.memset.p0i8.i64
 // CHECK: ret
 
 // Implicitly-generated destructor for ObjCArrayMember
 // CHECK-LABEL:    define linkonce_odr void @_ZN15ObjCArrayMemberD2Ev
 // CHECK:      [[BEGIN:%.*]] = getelementptr inbounds [2 x [3 x i8*]], [2 x [3 x i8*]]*
 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8*, i8** [[BEGIN]], i64 6
 // CHECK-NEXT: br label
 // CHECK:      [[PAST:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
 // CHECK-NEXT: [[CUR]] = getelementptr inbounds i8*, i8** [[PAST]], i64 -1
-// CHECK-NEXT: call void @objc_storeStrong(i8** [[CUR]], i8* null)
+// CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[CUR]], i8* null)
 // CHECK-NEXT: [[T1:%.*]] = icmp eq i8** [[CUR]], [[BEGIN]]
 // CHECK-NEXT: br i1 [[T1]],
 // CHECK:      ret void
 
 // Implicitly-generated copy constructor for ObjCArrayMember
 // CHECK-LABEL: define linkonce_odr void @_ZN15ObjCArrayMemberC2ERKS_
-// CHECK: call i8* @objc_retain
+// CHECK: call i8* @llvm.objc.retain
 // CHECK-NEXT: store i8*
 // CHECK: br i1
 // CHECK: ret
 
 // Implicitly-generated default constructor for ObjCBlockMember
 // CHECK-LABEL: define linkonce_odr void @_ZN15ObjCBlockMemberC2Ev
 // CHECK: store {{.*}} null,
 // CHECK-NEXT: ret void
 
 // Implicitly-generated destructor for ObjCBlockMember
 // CHECK-LABEL: define linkonce_odr void @_ZN15ObjCBlockMemberD2Ev
-// CHECK: call void @objc_storeStrong(i8*
+// CHECK: call void @llvm.objc.storeStrong(i8*
 // CHECK: ret
 
 // Implicitly-generated copy constructor for ObjCBlockMember
 // CHECK-LABEL: define linkonce_odr void @_ZN15ObjCBlockMemberC2ERKS_
-// CHECK: call i8* @objc_retainBlock
+// CHECK: call i8* @llvm.objc.retainBlock
 // CHECK: ret
 

test/CodeGenObjCXX/arc-weak.mm

 }
 // CHECK-LABEL: define void @_Z5test0PU6__weakP1B(
 // CHECK:       [[SRC:%.*]] = alloca [[B:%.*]]**, align 8
 // CHECK:       [[DEST:%.*]] = alloca [[A:%.*]]*, align 8
 // CHECK:       [[T0:%.*]] = load [[B]]**, [[B]]*** [[SRC]], align 8
 // CHECK-NEXT:  [[T1:%.*]] = bitcast [[B]]** [[T0]] to [[A]]**
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[A]]** [[DEST]] to i8**
 // CHECK-NEXT:  [[T3:%.*]] = bitcast [[A]]** [[T1]] to i8**
-// CHECK-NEXT:  call void @objc_copyWeak(i8** [[T2]], i8** [[T3]])
+// CHECK-NEXT:  call void @llvm.objc.copyWeak(i8** [[T2]], i8** [[T3]])
 // CHECK-NEXT:  [[T0:%.*]] = bitcast [[A]]** [[DEST]] to i8**
-// CHECK:       call void @objc_destroyWeak(i8** [[T0]])
+// CHECK:       call void @llvm.objc.destroyWeak(i8** [[T0]])
 
 void test1(__weak B **src) {
   __weak A *dest = static_cast<__weak B*&&>(*src);
 }
 // CHECK-LABEL: define void @_Z5test1PU6__weakP1B(
 // CHECK:       [[SRC:%.*]] = alloca [[B:%.*]]**, align 8
 // CHECK:       [[DEST:%.*]] = alloca [[A:%.*]]*, align 8
 // CHECK:       [[T0:%.*]] = load [[B]]**, [[B]]*** [[SRC]], align 8
 // CHECK-NEXT:  [[T1:%.*]] = bitcast [[B]]** [[T0]] to [[A]]**
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[A]]** [[DEST]] to i8**
 // CHECK-NEXT:  [[T3:%.*]] = bitcast [[A]]** [[T1]] to i8**
-// CHECK-NEXT:  call void @objc_moveWeak(i8** [[T2]], i8** [[T3]])
+// CHECK-NEXT:  call void @llvm.objc.moveWeak(i8** [[T2]], i8** [[T3]])
 // CHECK-NEXT:  [[T0:%.*]] = bitcast [[A]]** [[DEST]] to i8**
-// CHECK:       call void @objc_destroyWeak(i8** [[T0]])
+// CHECK:       call void @llvm.objc.destroyWeak(i8** [[T0]])

test/CodeGenObjCXX/arc.mm

 // The analogous ObjC testcase test46 in arr.m.
 void test0(__weak id *wp, __weak volatile id *wvp) {
   extern id test0_helper(void);
 
   // TODO: this is sub-optimal, we should retain at the actual call site.
   // TODO: in the non-volatile case, we do not need to be reloading.
 
   // CHECK:      [[T0:%.*]] = call i8* @_Z12test0_helperv()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = load i8**, i8*** {{%.*}}, align 8
-  // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
-  // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_retain(i8* [[T3]])
+  // CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[T2]], i8* [[T1]])
+  // CHECK-NEXT: [[T4:%.*]] = call i8* @llvm.objc.retain(i8* [[T3]])
   // CHECK-NEXT: store i8* [[T4]], i8**
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   id x = *wp = test0_helper();
 
   // CHECK:      [[T0:%.*]] = call i8* @_Z12test0_helperv()
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = load i8**, i8*** {{%.*}}, align 8
-  // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
-  // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T2]])
+  // CHECK-NEXT: [[T3:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[T2]], i8* [[T1]])
+  // CHECK-NEXT: [[T4:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T2]])
   // CHECK-NEXT: store i8* [[T4]], i8**
-  // CHECK-NEXT: call void @objc_release(i8* [[T1]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]])
   id y = *wvp = test0_helper();
 }
 
 // rdar://problem/9320648
 struct Test1_helper { Test1_helper(); };
 @interface Test1 @end
 @implementation Test1 { Test1_helper x; } @end
 // CHECK: define internal i8* @"\01-[Test1 .cxx_construct]"(
void test34(int cond) {
   // CHECK-NEXT: [[CONDCLEANUPSAVE:%.*]] = alloca i8*
   // CHECK-NEXT: [[CONDCLEANUP:%.*]] = alloca i1
   // CHECK-NEXT: store i32
   // CHECK-NEXT: [[STRONGP:%.*]] = bitcast i8** [[STRONG]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[STRONGP]])
   // CHECK-NEXT: store i8* null, i8** [[STRONG]]
   // CHECK-NEXT: [[WEAKP:%.*]] = bitcast i8** [[WEAK]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[WEAKP]])
-  // CHECK-NEXT: call i8* @objc_initWeak(i8** [[WEAK]], i8* null)
+  // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[WEAK]], i8* null)
 
   // CHECK-NEXT: [[T0:%.*]] = load i32, i32* [[COND]]
   // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
   // CHECK:      [[ARG:%.*]] = phi i8**
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP1]]
   // CHECK-NEXT: br i1 [[T0]],
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[ARG]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP1]]
   // CHECK-NEXT: br label
   // CHECK:      [[W0:%.*]] = phi i8* [ [[T0]], {{%.*}} ], [ undef, {{%.*}} ]
   // CHECK:      call void @_Z11test34_sinkPU15__autoreleasingP11objc_object(i8** [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: br i1 [[T0]],
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[TEMP1]]
-  // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
+  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]])
   // CHECK-NEXT: call void (...) @clang.arc.use(i8* [[W0]])
   // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[ARG]]
   // CHECK-NEXT: store i8* [[T1]], i8** [[ARG]]
-  // CHECK-NEXT: call void @objc_release(i8* [[T2]])
+  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]])
   // CHECK-NEXT: br label
 
   // CHECK:      [[T0:%.*]] = load i32, i32* [[COND]]
   // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
   // CHECK:      [[ARG:%.*]] = phi i8**
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP2]]
   // CHECK-NEXT: store i1 false, i1* [[CONDCLEANUP]]
   // CHECK-NEXT: br i1 [[T0]],
-  // CHECK:      [[T0:%.*]] = call i8* @objc_loadWeakRetained(i8** [[ARG]])
+  // CHECK:      [[T0:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[ARG]])
   // CHECK-NEXT: store i8* [[T0]], i8** [[CONDCLEANUPSAVE]]
   // CHECK-NEXT: store i1 true, i1* [[CONDCLEANUP]]
   // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP2]]
   // CHECK-NEXT: br label
   // CHECK:      call void @_Z11test34_sinkPU15__autoreleasingP11objc_object(i8** [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
   // CHECK-NEXT: br i1 [[T0]],
   // CHECK:      [[T0:%.*]] = load i8*, i8** [[TEMP2]]
-  // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[ARG]], i8* [[T0]])
+  // CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[ARG]], i8* [[T0]])
   // CHECK-NEXT: br label
 
-  // CHECK:      call void @objc_destroyWeak(i8** [[WEAK]])
+  // CHECK:      call void @llvm.objc.destroyWeak(i8** [[WEAK]])
   // CHECK:      ret void
 }
 
 struct Test35_Helper {
   static id makeObject1() __attribute__((ns_returns_retained));
   id makeObject2() __attribute__((ns_returns_retained));
   static id makeObject3();
   id makeObject4();
 };
 
 // CHECK-LABEL: define void @_Z6test3513Test35_HelperPS_
 void test35(Test35_Helper x0, Test35_Helper *x0p) {
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* @_ZN13Test35_Helper11makeObject1Ev
-  // CHECK-NOT: call i8* @objc_retain
+  // CHECK-NOT: call i8* @llvm.objc.retain
   id obj1 = Test35_Helper::makeObject1();
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* @_ZN13Test35_Helper11makeObject2Ev
-  // CHECK-NOT: call i8* @objc_retain
+  // CHECK-NOT: call i8* @llvm.objc.retain
   id obj2 = x0.makeObject2();
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* @_ZN13Test35_Helper11makeObject2Ev
-  // CHECK-NOT: call i8* @objc_retain
+  // CHECK-NOT: call i8* @llvm.objc.retain
   id obj3 = x0p->makeObject2();
   id (Test35_Helper::*pmf)() __attribute__((ns_returns_retained))
     = &Test35_Helper::makeObject2;
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* %
-  // CHECK-NOT: call i8* @objc_retain
+  // CHECK-NOT: call i8* @llvm.objc.retain
   id obj4 = (x0.*pmf)();
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* %
-  // CHECK-NOT: call i8* @objc_retain
+  // CHECK-NOT: call i8* @llvm.objc.retain
   id obj5 = (x0p->*pmf)();
 
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
   // CHECK-NEXT: ret void
 }
 
 // CHECK-LABEL: define void @_Z7test35b13Test35_HelperPS_
 void test35b(Test35_Helper x0, Test35_Helper *x0p) {
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* @_ZN13Test35_Helper11makeObject3Ev
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   id obj1 = Test35_Helper::makeObject3();
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* @_ZN13Test35_Helper11makeObject4Ev
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   id obj2 = x0.makeObject4();
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* @_ZN13Test35_Helper11makeObject4Ev
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   id obj3 = x0p->makeObject4();
   id (Test35_Helper::*pmf)() = &Test35_Helper::makeObject4;
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* %
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   id obj4 = (x0.*pmf)();
   // CHECK: call void @llvm.lifetime.start
   // CHECK: call i8* %
-  // CHECK: call i8* @objc_retain
+  // CHECK: call i8* @llvm.objc.retain
   id obj5 = (x0p->*pmf)();
 
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK: call void @llvm.lifetime.end
   // CHECK-NEXT: ret void
 }
 
 // rdar://problem/9603128
 // CHECK-LABEL: define i8* @_Z6test36P11objc_object(
 id test36(id z) {
-  // CHECK: objc_retain
-  // CHECK: objc_retain
-  // CHECK: objc_release
-  // CHECK: objc_autoreleaseReturnValue
+  // CHECK: llvm.objc.retain
+  // CHECK: llvm.objc.retain
+  // CHECK: llvm.objc.release
+  // CHECK: llvm.objc.autoreleaseReturnValue
   return z;
 }
 
 // Template instantiation side of rdar://problem/9817306
 @interface Test37
 + alloc;
 - init;
 - (NSArray *) array;
 @end
 template <class T> void test37(T *a) {
   for (id x in a.array) {
     use(x);
   }
 }
 extern template void test37<Test37>(Test37 *a);
 template void test37<Test37>(Test37 *a);
 // CHECK-LABEL: define weak_odr void @_Z6test37I6Test37EvPT_(
 // CHECK:      [[T0:%.*]] = call [[NSARRAY]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to [[NSARRAY]]* (i8*, i8*)*)(
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[NSARRAY]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
 // CHECK-NEXT: [[COLL:%.*]] = bitcast i8* [[T2]] to [[NSARRAY]]*
 
 // Make sure it's not immediately released before starting the iteration.
 // CHECK-NEXT: load i8*, i8** @OBJC_SELECTOR_REFERENCES_
 // CHECK-NEXT: [[T0:%.*]] = bitcast [[NSARRAY]]* [[COLL]] to i8*
 // CHECK-NEXT: @objc_msgSend
 
 // This bitcast is for the mutation check.
 // CHECK:      [[T0:%.*]] = bitcast [[NSARRAY]]* [[COLL]] to i8*
 // CHECK-NEXT: @objc_enumerationMutation
 
 // This bitcast is for the 'next' message send.
 // CHECK:      [[T0:%.*]] = bitcast [[NSARRAY]]* [[COLL]] to i8*
 // CHECK-NEXT: @objc_msgSend
 
 // This bitcast is for the final release.
 // CHECK:      [[T0:%.*]] = bitcast [[NSARRAY]]* [[COLL]] to i8*
-// CHECK-NEXT: call void @objc_release(i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
 
 template<typename T>
 void send_release() {
   [Test37 array];
 }
 
 // CHECK-LABEL: define weak_odr void @_Z12send_releaseIiEvv(
 // CHECK: call %0* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 // CHECK-NEXT: bitcast
-// CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue
+// CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue
 // CHECK-NEXT: bitcast
 // CHECK-NEXT: bitcast
-// CHECK-NEXT: call void @objc_release
+// CHECK-NEXT: call void @llvm.objc.release
 // CHECK-NEXT: ret void
 template void send_release<int>();
 
 template<typename T>
 Test37 *instantiate_init() {
   Test37 *result = [[Test37 alloc] init];
   return result;
 }
 
 // CHECK-LABEL: define weak_odr %2* @_Z16instantiate_initIiEP6Test37v
 // CHECK: call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 // CHECK: call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
-// CHECK: call i8* @objc_retain
-// CHECK: call void @objc_release
-// CHECK: call i8* @objc_autoreleaseReturnValue
+// CHECK: call i8* @llvm.objc.retain
+// CHECK: call void @llvm.objc.release
+// CHECK: call i8* @llvm.objc.autoreleaseReturnValue
 template Test37* instantiate_init<int>();
 
 // Just make sure that the AST invariants hold properly here,
 // i.e. that we don't crash.
 // The block should get bound in the full-expression outside
 // the statement-expression.
 template <class T> class Test38 {
   void test(T x) {

 // CHECK-NEXT: [[TEMP:%.*]] = alloca i8*
 // CHECK-NEXT: [[XP:%.*]] = bitcast i8** [[X]] to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XP]])
 // CHECK-NEXT: store i8* null, i8** [[X]]
 // CHECK:      [[T0:%.*]] = load i8*, i8** [[X]]
 // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP]]
 // CHECK:      @objc_msgSend
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[TEMP]]
-// CHECK-NEXT: call i8* @objc_retain(i8* [[T0]])
+// CHECK-NEXT: call i8* @llvm.objc.retain(i8* [[T0]])
 
 // Check that moves out of __weak variables are compiled to use objc_moveWeak.
 void test41(__weak id &&x) {
   __weak id y = static_cast<__weak id &&>(x);
 }
 // CHECK-LABEL: define void @_Z6test41OU6__weakP11objc_object
 // CHECK:      [[X:%.*]] = alloca i8**
 // CHECK:      [[Y:%.*]] = alloca i8*
 // CHECK:      [[T0:%.*]] = load i8**, i8*** [[X]]
-// CHECK-NEXT: call void @objc_moveWeak(i8** [[Y]], i8** [[T0]])
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[Y]])
+// CHECK-NEXT: call void @llvm.objc.moveWeak(i8** [[Y]], i8** [[T0]])
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[Y]])

test/CodeGenObjCXX/block-nested-in-lambda.mm

 // is captured by reference.
 
 // CHECK-LABEL: define void @_ZN18CaptureByReference5test1Ev(
 // CHECK-LABEL: define internal void @"_ZZN18CaptureByReference5test1EvENK3$_2clEv"(
 // CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 4
 // CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @"__block_descriptor_56_8_32s40s_e5_v8@?0l" to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8
 
 // CHECK-LABEL: define linkonce_odr hidden void @__copy_helper_block_8_32s40s(
-// CHECK-NOT: call void @objc_storeStrong(
+// CHECK-NOT: call void @llvm.objc.storeStrong(
 // CHECK: %[[V4:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 5
 // CHECK: %[[V5:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 5
 // CHECK: %[[BLOCKCOPY_SRC:.*]] = load i8*, i8** %[[V4]], align 8
 // CHECK: store i8* null, i8** %[[V5]], align 8
-// CHECK: call void @objc_storeStrong(i8** %[[V5]], i8* %[[BLOCKCOPY_SRC]])
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V5]], i8* %[[BLOCKCOPY_SRC]])
 // CHECK: %[[V6:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 6
 // CHECK: %[[V7:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 6
 // CHECK: %[[BLOCKCOPY_SRC2:.*]] = load i8*, i8** %[[V6]], align 8
 // CHECK: store i8* null, i8** %[[V7]], align 8
-// CHECK: call void @objc_storeStrong(i8** %[[V7]], i8* %[[BLOCKCOPY_SRC2]])
-// CHECK-NOT: call void @objc_storeStrong(
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V7]], i8* %[[BLOCKCOPY_SRC2]])
+// CHECK-NOT: call void @llvm.objc.storeStrong(
 // CHECK: ret void
 
 // CHECK-LABEL: define linkonce_odr hidden void @__destroy_helper_block_8_32s40s(
 // CHECK: %[[V2:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 5
 // CHECK: %[[V3:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 6
-// CHECK-NOT: call void @objc_storeStrong(
-// CHECK: call void @objc_storeStrong(i8** %[[V3]], i8* null)
-// CHECK: call void @objc_storeStrong(i8** %[[V2]], i8* null)
-// CHECK-NOT: call void @objc_storeStrong(
+// CHECK-NOT: call void @llvm.objc.storeStrong(
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V3]], i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** %[[V2]], i8* null)
+// CHECK-NOT: call void @llvm.objc.storeStrong(
 // CHECK: ret void
 
 void test1() {
   id a = getObj(), b = getObj(), c = getObj();
   [&a, b, c]{ ^{ a = 0; use(b); use(c); }(); }();
 }
 
 }

test/CodeGenObjCXX/destroy.mm

void test4() {
   tderived<int> *d2 = new tderived<int>;
   delete d2;
 }
 // CHECK-LABEL: define void @_Z5test4v()
 // CHECK: call void @_ZN8tderivedIiEC1Ev
 // CHECK: call void @_ZN8tderivedIiED1Ev
 
 // CHECK-LABEL: define linkonce_odr void @_ZN7derivedD2Ev
-// CHECK: call void @objc_storeStrong(i8** {{.*}}, i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** {{.*}}, i8* null)
 
 // CHECK-LABEL: define linkonce_odr void @_ZN8tderivedIiED2Ev
-// CHECK: call void @objc_storeStrong(i8** {{.*}}, i8* null)
+// CHECK: call void @llvm.objc.storeStrong(i8** {{.*}}, i8* null)

test/CodeGenObjCXX/lambda-expressions.mm

 // MRC: call i32 ()* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 ()* (i8*, i8*)*)
 // MRC: call i32 ()* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 ()* (i8*, i8*)*)
 // MRC: ret i32 ()*
 
 // ARC-LABEL: define i32 ()* @_Z1fv(
 // ARC-LABEL: define internal i32 ()* @"_ZZ1fvENK3$_0cvU13block_pointerFivEEv"
 // ARC: store i8* bitcast (i8** @_NSConcreteStackBlock to i8*)
 // ARC: store i8* bitcast (i32 (i8*)* @"___ZZ1fvENK3$_0cvU13block_pointerFivEEv_block_invoke" to i8*)
-// ARC: call i8* @objc_retainBlock
-// ARC: call i8* @objc_autoreleaseReturnValue
+// ARC: call i8* @llvm.objc.retainBlock
+// ARC: call i8* @llvm.objc.autoreleaseReturnValue
 
 typedef int (^fp)();
 fp global;
 void f2() { global = []{ return 3; }; }
 
 // MRC: define void @_Z2f2v() [[NUW:#[0-9]+]] {
 // MRC: store i8* bitcast (i32 (i8*)* @___Z2f2v_block_invoke to i8*),
 // MRC-NOT: call
 // MRC: ret void
 // ("global" contains a dangling pointer after this function runs.)
 
 // ARC: define void @_Z2f2v() [[NUW:#[0-9]+]] {
 // ARC: store i8* bitcast (i32 (i8*)* @___Z2f2v_block_invoke to i8*),
-// ARC: call i8* @objc_retainBlock
-// ARC: call void @objc_release
+// ARC: call i8* @llvm.objc.retainBlock
+// ARC: call void @llvm.objc.release
 // ARC-LABEL: define internal i32 @___Z2f2v_block_invoke
 // ARC: call i32 @"_ZZ2f2vENK3$_1clEv
 
 template <class T> void take_lambda(T &&lambda) { lambda(); }
 void take_block(void (^block)()) { block(); }
 
 // rdar://13800041
 @interface A

 // ARC:   store i32 %{{.*}}, i32* %[[CAPTURE0]]
 
 // ARC: define internal void @"_ZZN13LambdaCapture4foo1ERiENK3$_3clEv"(%[[LAMBDACLASS]]* %{{.*}})
 // ARC:   %[[BLOCK:.*]] = alloca <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>
 // ARC:   %[[CAPTURE1:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>* %[[BLOCK]], i32 0, i32 5
 // ARC:   store i32 %{{.*}}, i32* %[[CAPTURE1]]
 
 // ARC-LABEL: define internal void @"_ZZ10-[Foo foo]ENK3$_4clEv"(
-// ARC-NOT: @objc_storeStrong(
+// ARC-NOT: @llvm.objc.storeStrong(
 // ARC: ret void
 
 // ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_3clEv_block_invoke"
 // ARC:   %[[CAPTURE2:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>* %{{.*}}, i32 0, i32 5
 // ARC:   store i32 %{{.*}}, i32* %[[CAPTURE2]]
 
 // ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_3clEv_block_invoke_2"(i8* %{{.*}})
 // ARC:   %[[CAPTURE3:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>* %{{.*}}, i32 0, i32 5

test/CodeGenObjCXX/literals.mm

void test_array() {
   // Initializing first element
   // CHECK: [[PTR1:%.*]] = bitcast i8** [[ARR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTR1]])
   // CHECK: [[ELEMENT0:%[a-zA-Z0-9.]+]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 0
   // CHECK-NEXT: [[TMP_CAST:%.*]] = bitcast {{.*}} [[TMPX]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 1, i8* [[TMP_CAST]])
   // CHECK-NEXT: call void @_ZN1XC1Ev({{.*}} [[TMPX]])
   // CHECK-NEXT: [[OBJECT0:%[a-zA-Z0-9.]+]] = invoke i8* @_ZNK1XcvP11objc_objectEv
-  // CHECK: [[RET0:%[a-zA-Z0-9.]+]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[OBJECT0]])
+  // CHECK: [[RET0:%[a-zA-Z0-9.]+]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[OBJECT0]])
   // CHECK: store i8* [[RET0]], i8** [[ELEMENT0]]
   
   // Initializing the second element
   // CHECK: [[ELEMENT1:%[a-zA-Z0-9.]+]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 1
   // CHECK-NEXT: [[TMP_CAST:%.*]] = bitcast {{.*}} [[TMPY]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 1, i8* [[TMP_CAST]])
   // CHECK-NEXT: invoke void @_ZN1YC1Ev({{.*}} [[TMPY]])
   // CHECK: [[OBJECT1:%[a-zA-Z0-9.]+]] = invoke i8* @_ZNK1YcvP11objc_objectEv
-  // CHECK: [[RET1:%[a-zA-Z0-9.]+]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[OBJECT1]])
+  // CHECK: [[RET1:%[a-zA-Z0-9.]+]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[OBJECT1]])
   // CHECK: store i8* [[RET1]], i8** [[ELEMENT1]]
 
   // Build the array
   // CHECK: {{invoke.*@objc_msgSend}}
-  // CHECK: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
   id arr = @[ X(), Y() ];
 
   // Destroy temporaries
   // CHECK-NOT: ret void
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NOT: ret void
   // CHECK: invoke void @_ZN1YD1Ev
   // CHECK-NOT: ret void
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: call void @_ZN1XD1Ev
   // CHECK-NOT: ret void
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: [[PTR2:%.*]] = bitcast i8** [[ARR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTR2]])
   // CHECK-NEXT: ret void
 
   // Check cleanups
-  // CHECK: call void @objc_release
-  // CHECK-NOT: call void @objc_release
+  // CHECK: call void @llvm.objc.release
+  // CHECK-NOT: call void @llvm.objc.release
   // CHECK: invoke void @_ZN1YD1Ev
-  // CHECK: call void @objc_release
-  // CHECK-NOT: call void @objc_release
+  // CHECK: call void @llvm.objc.release
+  // CHECK-NOT: call void @llvm.objc.release
   // CHECK: invoke void @_ZN1XD1Ev
-  // CHECK-NOT: call void @objc_release
+  // CHECK-NOT: call void @llvm.objc.release
   // CHECK: unreachable
 }
 
 // CHECK-LABEL: define weak_odr void @_Z24test_array_instantiationIiEvv
 template<typename T>
 void test_array_instantiation() {
   // CHECK: [[ARR:%[a-zA-Z0-9.]+]] = alloca i8*
   // CHECK: [[OBJECTS:%[a-zA-Z0-9.]+]] = alloca [2 x i8*]
 
   // Initializing first element
   // CHECK:      [[PTR1:%.*]] = bitcast i8** [[ARR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTR1]])
   // CHECK: [[ELEMENT0:%[a-zA-Z0-9.]+]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 0
   // CHECK: call void @_ZN1XC1Ev
   // CHECK-NEXT: [[OBJECT0:%[a-zA-Z0-9.]+]] = invoke i8* @_ZNK1XcvP11objc_objectEv
-  // CHECK: [[RET0:%[a-zA-Z0-9.]+]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[OBJECT0]])
+  // CHECK: [[RET0:%[a-zA-Z0-9.]+]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[OBJECT0]])
   // CHECK: store i8* [[RET0]], i8** [[ELEMENT0]]
   
   // Initializing the second element
   // CHECK: [[ELEMENT1:%[a-zA-Z0-9.]+]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 1
   // CHECK: invoke void @_ZN1YC1Ev
   // CHECK: [[OBJECT1:%[a-zA-Z0-9.]+]] = invoke i8* @_ZNK1YcvP11objc_objectEv
-  // CHECK: [[RET1:%[a-zA-Z0-9.]+]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[OBJECT1]])
+  // CHECK: [[RET1:%[a-zA-Z0-9.]+]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[OBJECT1]])
   // CHECK: store i8* [[RET1]], i8** [[ELEMENT1]]
 
   // Build the array
   // CHECK: {{invoke.*@objc_msgSend}}
-  // CHECK: call i8* @objc_retainAutoreleasedReturnValue
+  // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
   id arr = @[ X(), Y() ];
 
   // Destroy temporaries
   // CHECK-NOT: ret void
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NOT: ret void
   // CHECK: invoke void @_ZN1YD1Ev
   // CHECK-NOT: ret void
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: call void @_ZN1XD1Ev
   // CHECK-NOT: ret void
-  // CHECK: call void @objc_release
+  // CHECK: call void @llvm.objc.release
   // CHECK-NEXT: [[PTR2]] = bitcast i8** [[ARR]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTR2]])
   // CHECK-NEXT: ret void
 
   // Check cleanups
-  // CHECK: call void @objc_release
-  // CHECK-NOT: call void @objc_release
+  // CHECK: call void @llvm.objc.release
+  // CHECK-NOT: call void @llvm.objc.release
   // CHECK: invoke void @_ZN1YD1Ev
-  // CHECK: call void @objc_release
-  // CHECK-NOT: call void @objc_release
+  // CHECK: call void @llvm.objc.release
+  // CHECK-NOT: call void @llvm.objc.release
   // CHECK: invoke void @_ZN1XD1Ev
-  // CHECK-NOT: call void @objc_release
+  // CHECK-NOT: call void @llvm.objc.release
   // CHECK: unreachable
 }
 
 template void test_array_instantiation<int>();
 

test/CodeGenObjCXX/microsoft-abi-arc-param-order.mm

 // RUN: %clang_cc1 -mconstructor-aliases -fobjc-arc -triple i686-pc-win32 -emit-llvm -o - %s | FileCheck %s
 
 struct A {
   A();
   A(const A &);
   ~A();
   int a;
 };
 
 // Verify that we destruct things from left to right in the MS C++ ABI: a, b, c, d.
 //
 // CHECK-LABEL: define dso_local void @"?test_arc_order@@YAXUA@@PAUobjc_object@@01@Z"
 // CHECK:                       (<{ %struct.A, i8*, %struct.A, i8* }>* inalloca)
 void test_arc_order(A a, id __attribute__((ns_consumed)) b , A c, id __attribute__((ns_consumed)) d) {
   // CHECK: call x86_thiscallcc void @"??1A@@QAE@XZ"(%struct.A* %{{.*}})
-  // CHECK: call void @objc_storeStrong(i8** %{{.*}}, i8* null)
+  // CHECK: call void @llvm.objc.storeStrong(i8** %{{.*}}, i8* null)
   // CHECK: call x86_thiscallcc void @"??1A@@QAE@XZ"(%struct.A* %{{.*}})
-  // CHECK: call void @objc_storeStrong(i8** %{{.*}}, i8* null)
+  // CHECK: call void @llvm.objc.storeStrong(i8** %{{.*}}, i8* null)
   // CHECK: ret void
 }

test/CodeGenObjCXX/mrc-weak.mm

 //                         ^ Factory
 @interface Foo : Object {
   __weak id ivar;
 }
 @end
 
 @implementation Foo
 // CHECK-LABEL: define internal void @"\01-[Foo .cxx_destruct]"
-// CHECK: call void @objc_destroyWeak
+// CHECK: call void @llvm.objc.destroyWeak
 @end
 
 
 void test1(__weak id x) {}
 // CHECK-LABEL: define void @_Z5test1P11objc_object(
 // CHECK:      [[X:%.*]] = alloca i8*,
-// CHECK-NEXT: objc_initWeak
-// CHECK-NEXT: objc_destroyWeak
+// CHECK-NEXT: llvm.objc.initWeak
+// CHECK-NEXT: llvm.objc.destroyWeak
 // CHECK-NEXT: ret void
 
 void test2(id y) {
   __weak id z = y;
 }
 // CHECK-LABEL: define void @_Z5test2P11objc_object(
 // CHECK:      [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: [[Z:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-// CHECK-NEXT: call i8* @objc_initWeak(i8** [[Z]], i8* [[T0]])
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[Z]])
+// CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[Z]], i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[Z]])
 // CHECK-NEXT: ret void
 
 void test3(id y) {
   __weak id z;
   z = y;
 }
 // CHECK-LABEL: define void @_Z5test3P11objc_object(
 // CHECK:      [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: [[Z:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: store i8* null, i8** [[Z]]
 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[Y]]
-// CHECK-NEXT: call i8* @objc_storeWeak(i8** [[Z]], i8* [[T0]])
-// CHECK-NEXT: call void @objc_destroyWeak(i8** [[Z]])
+// CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[Z]], i8* [[T0]])
+// CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[Z]])
 // CHECK-NEXT: ret void
 
 void test4(__weak id *p) {
   id y = *p;
 }
 // CHECK-LABEL: define void @_Z5test4PU6__weakP11objc_object(
 // CHECK:      [[P:%.*]] = alloca i8**,
 // CHECK-NEXT: [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load i8**, i8*** [[P]]
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_loadWeak(i8** [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.loadWeak(i8** [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT: ret void
 
 void test5(__weak id *p) {
   id y = [*p retain];
 }
 // CHECK-LABEL: define void @_Z5test5PU6__weakP11objc_object
 // CHECK:      [[P:%.*]] = alloca i8**,
 // CHECK-NEXT: [[Y:%.*]] = alloca i8*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load i8**, i8*** [[P]]
-// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T0]])
+// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T0]])
 // CHECK-NEXT: store i8* [[T1]], i8** [[Y]]
 // CHECK-NEXT: ret void
 
 void test6(__weak Foo **p) {
   Foo *y = [*p retain];
 }
 // CHECK-LABEL: define void @_Z5test6PU6__weakP3Foo
 // CHECK:      [[P:%.*]] = alloca [[FOO:%.*]]**,
 // CHECK-NEXT: [[Y:%.*]] = alloca [[FOO]]*,
 // CHECK-NEXT: store
 // CHECK-NEXT: [[T0:%.*]] = load [[FOO]]**, [[FOO]]*** [[P]]
 // CHECK-NEXT: [[T1:%.*]] = bitcast [[FOO]]** [[T0]] to i8**
-// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_loadWeakRetained(i8** [[T1]])
+// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[T1]])
 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[FOO]]*
 // CHECK-NEXT: store [[FOO]]* [[T3]], [[FOO]]** [[Y]]
 // CHECK-NEXT: ret void
 
 extern "C" id get_object(void);
 extern "C" void use_block(void (^)(void));
 
 void test7(void) {
   __weak Foo *p = get_object();
   use_block(^{ [p run ]; });
 }
 // CHECK-LABEL: define void @_Z5test7v
 // CHECK:       [[P:%.*]] = alloca [[FOO]]*,
 // CHECK:       [[T0:%.*]] = call i8* @get_object()
 // CHECK-NEXT:  [[T1:%.*]] = bitcast i8* [[T0]] to [[FOO]]*
 // CHECK-NEXT:  [[T2:%.*]] = bitcast [[FOO]]** [[P]] to i8**
 // CHECK-NEXT:  [[T3:%.*]] = bitcast [[FOO]]* [[T1]] to i8*
-// CHECK-NEXT:  call i8* @objc_initWeak(i8** [[T2]], i8* [[T3]])
-// CHECK:       call void @objc_copyWeak
+// CHECK-NEXT:  call i8* @llvm.objc.initWeak(i8** [[T2]], i8* [[T3]])
+// CHECK:       call void @llvm.objc.copyWeak
 // CHECK:       call void @use_block
-// CHECK:       call void @objc_destroyWeak
+// CHECK:       call void @llvm.objc.destroyWeak
 
 // CHECK-LABEL: define linkonce_odr hidden void @__copy_helper_block
-// CHECK:       @objc_copyWeak
+// CHECK:       @llvm.objc.copyWeak
 
 // CHECK-LABEL: define linkonce_odr hidden void @__destroy_helper_block
-// CHECK:       @objc_destroyWeak
+// CHECK:       @llvm.objc.destroyWeak
 
 void test8(void) {
   __block __weak Foo *p = get_object();
   use_block(^{ [p run ]; });
 }
 // CHECK-LABEL: define void @_Z5test8v
-// CHECK:       call i8* @objc_initWeak
-// CHECK-NOT:   call void @objc_copyWeak
+// CHECK:       call i8* @llvm.objc.initWeak
+// CHECK-NOT:   call void @llvm.objc.copyWeak
 // CHECK:       call void @use_block
-// CHECK:       call void @objc_destroyWeak
+// CHECK:       call void @llvm.objc.destroyWeak
 
 // CHECK-LABEL: define internal void @__Block_byref_object_copy
-// CHECK:       call void @objc_moveWeak
+// CHECK:       call void @llvm.objc.moveWeak
 
 // CHECK-LABEL: define internal void @__Block_byref_object_dispose
-// CHECK:       call void @objc_destroyWeak
+// CHECK:       call void @llvm.objc.destroyWeak
 
 // CHECK-LABEL: define void @_Z14test9_baselinev()
 // CHECK:       define linkonce_odr hidden void @__copy_helper
 // CHECK:       define linkonce_odr hidden void @__destroy_helper
 void test9_baseline(void) {
   Foo *p = get_object();
   use_block(^{ [p run]; });
 }

test/CodeGenObjCXX/objc-weak.mm

 
 // Copy Assignment Operator
 // CHECK-LABEL: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.A* @_ZN1AaSERKS_(
 // CHECK:       [[THISADDR:%this.*]] = alloca [[A:.*]]*
 // CHECK:       [[OBJECTADDR:%.*]] = alloca [[A:.*]]*
 // CHECK:       [[THIS:%this.*]] = load [[A]]*, [[A]]** [[THISADDR]]
 // CHECK:       [[OBJECT:%.*]] = load [[A]]*, [[A]]** [[OBJECTADDR]]
 // CHECK:       [[T0:%.*]] = getelementptr inbounds [[A]], [[A]]* [[OBJECT]], i32 0, i32 0
-// CHECK-NEXT:  [[T1:%.*]] = call i8* @objc_loadWeak(i8** [[T0]])
+// CHECK-NEXT:  [[T1:%.*]] = call i8* @llvm.objc.loadWeak(i8** [[T0]])
 // CHECK-NEXT:  [[T2:%.*]] = getelementptr inbounds [[A]], [[A]]* [[THIS]], i32 0, i32 0
-// CHECK-NEXT:  [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
+// CHECK-NEXT:  [[T3:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[T2]], i8* [[T1]])
 
 // Move Assignment Operator
 // CHECK-LABEL: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.A* @_ZN1AaSEOS_(
 // CHECK:       [[THISADDR:%this.*]] = alloca [[A:.*]]*
 // CHECK:       [[OBJECTADDR:%.*]] = alloca [[A:.*]]*
 // CHECK:       [[THIS:%this.*]] = load [[A]]*, [[A]]** [[THISADDR]]
 // CHECK:       [[OBJECT:%.*]] = load [[A]]*, [[A]]** [[OBJECTADDR]]
 // CHECK:       [[T0:%.*]] = getelementptr inbounds [[A]], [[A]]* [[OBJECT]], i32 0, i32 0
-// CHECK-NEXT:  [[T1:%.*]] = call i8* @objc_loadWeak(i8** [[T0]])
+// CHECK-NEXT:  [[T1:%.*]] = call i8* @llvm.objc.loadWeak(i8** [[T0]])
 // CHECK-NEXT:  [[T2:%.*]] = getelementptr inbounds [[A]], [[A]]* [[THIS]], i32 0, i32 0
-// CHECK-NEXT:  [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
+// CHECK-NEXT:  [[T3:%.*]] = call i8* @llvm.objc.storeWeak(i8** [[T2]], i8* [[T1]])
 
 // Default Constructor
 // CHECK-LABEL: define linkonce_odr void @_ZN1AC2Ev(
 // CHECK:       [[THISADDR:%this.*]] = alloca [[A:.*]]*
 // CHECK:       [[THIS:%this.*]] = load [[A]]*, [[A]]** [[THISADDR]]
 // CHECK:       [[T0:%.*]] = getelementptr inbounds [[A]], [[A]]* [[THIS]], i32 0, i32 0
 // CHECK-NEXT:  store i8* null, i8** [[T0]]
 
 // Copy Constructor
 // CHECK-LABEL: define linkonce_odr void @_ZN1AC2ERKS_(
 // CHECK:       [[THISADDR:%this.*]] = alloca [[A:.*]]*
 // CHECK:       [[OBJECTADDR:%.*]] = alloca [[A:.*]]*
 // CHECK:       [[THIS:%this.*]] = load [[A]]*, [[A]]** [[THISADDR]]
 // CHECK:       [[T0:%.*]] = getelementptr inbounds [[A]], [[A]]* [[THIS]], i32 0, i32 0
 // CHECK-NEXT:  [[OBJECT:%.*]] = load [[A]]*, [[A]]** [[OBJECTADDR]]
 // CHECK-NEXT:  [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[OBJECT]], i32 0, i32 0
-// CHECK-NEXT:  call void @objc_copyWeak(i8** [[T0]], i8** [[T1]])
+// CHECK-NEXT:  call void @llvm.objc.copyWeak(i8** [[T0]], i8** [[T1]])
 
 // Move Constructor
 // CHECK-LABEL: define linkonce_odr void @_ZN1AC2EOS_(
 // CHECK:       [[THISADDR:%this.*]] = alloca [[A:.*]]*
 // CHECK:       [[OBJECTADDR:%.*]] = alloca [[A:.*]]*
 // CHECK:       [[THIS:%this.*]] = load [[A]]*, [[A]]** [[THISADDR]]
 // CHECK:       [[T0:%.*]] = getelementptr inbounds [[A]], [[A]]* [[THIS]], i32 0, i32 0
 // CHECK-NEXT:  [[OBJECT:%.*]] = load [[A]]*, [[A]]** [[OBJECTADDR]]
 // CHECK-NEXT:  [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[OBJECT]], i32 0, i32 0
-// CHECK-NEXT:  call void @objc_moveWeak(i8** [[T0]], i8** [[T1]])
+// CHECK-NEXT:  call void @llvm.objc.moveWeak(i8** [[T0]], i8** [[T1]])
 
 // Destructor
 // CHECK-LABEL: define linkonce_odr void @_ZN1AD2Ev(
 // CHECK:       [[THISADDR:%this.*]] = alloca [[A:.*]]*
 // CHECK:       [[THIS:%this.*]] = load [[A]]*, [[A]]** [[THISADDR]]
 // CHECK-NEXT:  [[T0:%.*]] = getelementptr inbounds [[A]], [[A]]* [[THIS]], i32 0, i32 0
-// CHECK-NEXT:  call void @objc_destroyWeak(i8** [[T0]])
+// CHECK-NEXT:  call void @llvm.objc.destroyWeak(i8** [[T0]])
 

test/SemaObjC/arc-objc-lifetime-conflict.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fobjc-arc -fobjc-runtime-has-weak %s -emit-llvm -o - | FileCheck %s
 
 // CHECK: bitcast {{.*}} %self_weak_s_w_s
-// CHECK-NEXT: objc_destroyWeak
+// CHECK-NEXT: llvm.objc.destroyWeak
 // CHECK-NEXT: bitcast {{.*}} %self_strong_w_s
-// CHECK-NEXT: objc_storeStrong
+// CHECK-NEXT: llvm.objc.storeStrong
 // CHECK-NEXT: bitcast {{.*}} %self_weak_s
-// CHECK-NEXT: objc_destroyWeak
+// CHECK-NEXT: llvm.objc.destroyWeak
 // CHECK-NEXT: bitcast {{.*}} %self_weak_s3
-// CHECK-NEXT: objc_destroyWeak
+// CHECK-NEXT: llvm.objc.destroyWeak
 // CHECK-NEXT: bitcast {{.*}} %self_strong3
-// CHECK-NEXT: objc_storeStrong
+// CHECK-NEXT: llvm.objc.storeStrong
 // CHECK-NEXT: bitcast {{.*}} %self_strong2
-// CHECK-NEXT: objc_storeStrong
+// CHECK-NEXT: llvm.objc.storeStrong
 // CHECK-NEXT: bitcast {{.*}} %self_strong
-// CHECK-NEXT: objc_storeStrong
+// CHECK-NEXT: llvm.objc.storeStrong
 @interface NSObject
 @end
 @interface A : NSObject
 @end
 @implementation A
 - (void)test {
   __attribute__((objc_ownership(strong))) __typeof__(self) self_strong;
   __attribute__((objc_ownership(strong))) __typeof__(self_strong) self_strong2;
   __attribute__((objc_ownership(strong))) __typeof__(self_strong2) self_strong3;
   __attribute__((objc_ownership(weak))) __typeof__(self_strong3) self_weak_s3;
  
   __attribute__((objc_ownership(weak))) __typeof__(self_strong) self_weak_s;
   __attribute__((objc_ownership(strong))) __typeof__(self_weak_s) self_strong_w_s;
   __attribute__((objc_ownership(weak))) __typeof__(self_strong_w_s) self_weak_s_w_s;
 }
 @end