Convert some ObjC msgSends to runtime calls

[pete]

Summary

It is faster to directly call the ObjC runtime for methods such as retain/release instead of sending a message to those functions.

This patch adds support for converting messages to retain/release/alloc/autorelease to their equivalent runtime calls.

Tests included for the positive case of applying this transformation, negative tests that we ensure we only convert "alloc" to objc_alloc, not "alloc2", and also a driver test to ensure we enable this only for supported runtime versions.

[pete]

Updated the driver test to ensure that the option is set for tvOS and watchOS.

[rjmccall]

include/clang/Basic/LangOptions.def

194 ↗

(On Diff #40365)

I think this can just be a code-gen option.

Also, please use the description "Replace certain message sends with calls to ObjC runtime entrypoints".

include/clang/Basic/ObjCRuntime.h

179 ↗

(On Diff #40365)

This isn't really an appropriate comment. Please use:

Does this runtime provide ARC entrypoints that are likely to be faster than
an ordinary message send of the appropriate selector?

The ARC entrypoints are guaranteed to be equivalent to just sending the
corresponding message.  If the entrypoint is implemented naively as just a
message send, using it is a trade-off: it sacrifices a few cycles of overhead
to save a small amount of code.  However, it's possible for runtimes to detect
and special-case classes that use "standard" retain/release behavior; if that's
dynamically a large proportion of all retained objects, using the entrypoint will
also be faster than using a message send.

When this method returns true, Clang will turn non-super message sends of
certain selectors into calls to the correspond entrypoint:
  retain => objc_retain
  release => objc_release

182 ↗

(On Diff #40365)

Would you mind asking our runtime folks about the fragile runtime? We do provide these entrypoints there.

lib/CodeGen/CGObjCMac.cpp

1871 ↗

(On Diff #40365)

Hmm. It would be better if you could implement this in CGObjC instead of CGObjCMac so that it automatically works on all runtimes.

Also, you need to gate this on !IsSuper. Please add a test for that case.

1876 ↗

(On Diff #40365)

You really ought to have a separate query on the runtime for whether this is okay, since objc_alloc isn't one of the standard ARC entrypoints.

I'm not sure what that ends up meaning for the code-gen option. It makes sense to just have one command-line option: we should have the target's default rules for rewriting message sends, there should be a runtime option to suppress it for people who need to (e.g. because they're writing a runtime), end of story. Maybe what you should do is have the driver pass down the suppression option, if indeed it was provided last, and then have the frontend enable stuff based on the target runtime if the suppression option wasn't given; that is, -fno-objc-X would be the -cc1 flag, not -fobjc-X.

test/CodeGenObjC/convert-messages-to-runtime-calls.m

38 ↗

(On Diff #40365)

You should also test that sending "alloc" with a dynamic receiver work. This includes something like [self alloc] in a class method.

[stephanemoore]

I hope that it's not presumptuous of me to inquire but I was wondering if the intent of this patch is to optimize calls to RR methods (and alloc) in non-ARC code? Would I be correct in assuming that clang will already emit direct calls to relevant RR runtime functions when ARC is enabled?

[rjmccall]

In D14737#291481, @stephanemoore wrote:

I hope that it's not presumptuous of me to inquire but I was wondering if the intent of this patch is to optimize calls to RR methods (and alloc) in non-ARC code? Would I be correct in assuming that clang will already emit direct calls to relevant RR runtime functions when ARC is enabled?

Correct. The patch turns ObjC message sends of -retain, -release, and +alloc into calls to the runtime functions we already use in ARC.

This is largely irrelevant in ARC because it's illegal to write an ObjC message send of -retain or -release. The change to +alloc would still apply, however.

[rjmccall]

include/clang/Basic/ObjCRuntime.h

182 ↗

(On Diff #40426)

I went ahead and asked Greg, and he agreed that it's best to not enable this on the Mac fragile runtime. The functions exist, but they aren't profitable to call, other than a small code-size decrease.

[pete]

Updated with the following changes:

• Removed the -f-objc-X option and made the -fno-objc-X option be codegen only.
• Updated all the comments to be what John suggested.
• Added a method (shouldUseRuntimeFunctionsForAlloc) to single out the alloc case with its own checks.
• Added check and test case for IsSuper
• Added test for retain of self.
• The driver test now only checks for whether the flag is forwarded correctly as the target checks are done during codegen.
• The CodeGen test now includes all the variants for macos, fragile, iOS, tvos and watchOS.

Given we now have 2 runtime methods to check, I tried to reduce duplication by splitting alloc out of the switch. The alternative is to check for shouldUseARCFunctionsForRetainRelease() in each of the retain/release/autorelease cases. I'm fine with either solution.

I wasn't able to move the code to CGObjC. Unfortunately there's no common EmitMessageSend method which is shared by CGObjCMac and CGObjCGNU. I could move this to a helper in CGObjC and call the helper from CGObjCMac and CGObjCGNU if thats preferable. Perhaps we should do that in a follow up only if the CGObjCGNU valid targets were ever true for the versions being checked in shouldUseARCFunctionsForRetainRelease.

[pete]

After chatting with John offline, he mentioned that this code could be shared with all ObjC CG's if I put it in EmitObjCMessageExpr.

This moves it here and also checks that we don't do the retain/release call->msgSend optimization when GC is enabled. There's also a test for that case.

[rjmccall]

By "in CGObjC", I mean you should be able to do it in CodeGenFunction::EmitObjCMessageExpr. Maybe put it in a separate function like

static llvm::Value *tryGenerateSpecializedMessageSend(...)

and then do something like

} else if (llvm::Value *SpecializedResult = tryGenerateSpecializedMessageSend(...)) {
  result = RValue::get(SpecializedResult);
} else {

right before the call to GenerateMessageSend.

include/clang/Basic/ObjCRuntime.h

176 ↗

(On Diff #40703)

The vertical whitespace is good, but please continue the doc comments across it.

207 ↗

(On Diff #40703)

You can just say "alloc" here. :)

include/clang/Driver/Options.td

896 ↗

(On Diff #40703)

It's fine to have both the "yes" and "no" options; I just meant that only the "no" option needs to be a cc1 option.

lib/CodeGen/CGObjCMac.cpp

1874 ↗

(On Diff #40703)

I'd just write this as a switch over the method family. The runtime check isn't unreasonable to duplicate into each of the cases; also, in the dominant case it will be true, so we're not really saving any work in practice by doing it early. It's the method family check that will usually avoid the rest of the work.

We don't really care if we have a method declaration; if there's no method, you can just ask the selector for its method family. That won't be cached, though, and it's implemented with string comparisons, so please be sure to avoid calling it multiple times.

Please loosen the type restrictions here. You shouldn't need to restrict the receiver type, and any ObjC pointer type should be fine for the return type. Of course, you'll need to add bitcasts to/from i8*, but that's easy enough.

1883 ↗

(On Diff #40703)

Oh. Additional check: don't do this if GC != NonGC.

1897 ↗

(On Diff #40703)

This has precise lifetime, actually. Not that it really matters, since the ARC optimizer should be disabled, but it's best to be correct.

[pete]

Thanks for all the feedback!

I've addressed all of your previous feedback and also applied clang-format to the whole patch as some parts were looking questionable.

BTW, each of the implementations of EmitObjC* ultimately called to emitARCValueOperation which handled the bit cast insertion when the dest type was not an id. I've added a check for this in the test case, and verified that the IR looked good.

Let me know what you think. Thanks!

[rjmccall]

The casts done by emitARCValueOperation will handle the input, but they don't quite handle the result properly. The right test case here is a method named "retain" that's declared to return something completely unrelated to its receiver type, e.g.

@class A;
@interface B
- (A*) retain;
@end

You should also add a test case for unusual return types that your mechanism just can't support and that need to go through the ordinary message-send emission, like returning a float.

test/CodeGenObjC/convert-messages-to-runtime-calls.m

62 ↗

(On Diff #40719)

You already test this case. If you make retain_self a class method, this will be a class message; but it should still be okay to use objc_retain.

[pete]

Added a couple of tests for retain returning types other than id. Returning a pointer should still be converted to a call, while returning a non-pointer such as float will get a message instead.

I walked through the code in the debugger to check on the return cast. Turns out it is handled at the very end of emitARCValueOperation as follows:

// Cast the result back to the original type.
return CGF.Builder.CreateBitCast(call, origType);

[rjmccall]

In D14737#293967, @pete wrote:

Added a couple of tests for retain returning types other than id. Returning a pointer should still be converted to a call, while returning a non-pointer such as float will get a message instead.

I walked through the code in the debugger to check on the return cast. Turns out it is handled at the very end of emitARCValueOperation as follows:

// Cast the result back to the original type.
return CGF.Builder.CreateBitCast(call, origType);

Right, that'll cast back to the original type. That will be the type of the receiver of the message, which is not necessarily the type of the result of the message.

[pete]

Hi John

Sorry, getting back to this after way too long!

In D14737#294218, @rjmccall wrote:

In D14737#293967, @pete wrote:

Added a couple of tests for retain returning types other than id. Returning a pointer should still be converted to a call, while returning a non-pointer such as float will get a message instead.

I walked through the code in the debugger to check on the return cast. Turns out it is handled at the very end of emitARCValueOperation as follows:

// Cast the result back to the original type.
return CGF.Builder.CreateBitCast(call, origType);

Right, that'll cast back to the original type. That will be the type of the receiver of the message, which is not necessarily the type of the result of the message.

I stepped through this one in the debugger to make sure I had it right.

So the reason the bit cast ends up not being needed is because we restricted this optimization to cases where the result type "isObjCObjectPointerType()" which conveniently ends up begin i8* and is exactly the same type as the message receiver. I guess if either the receiver type or the result type wasn't represented as i8* then the IRBuilder would have crashed.

If we permitted converting say messaging (int*)retain to a call to objc_retain then the bit cast would be needed. Would you like me to permit this change on functions returning anything other than isObjCObjectPointerType(), eg, change that to "isAnyPointerType()"?

Cheers,
Pete

[rjmccall]

In D14737#373532, @pete wrote:

I stepped through this one in the debugger to make sure I had it right.

So the reason the bit cast ends up not being needed is because we restricted this optimization to cases where the result type "isObjCObjectPointerType()" which conveniently ends up begin i8* and is exactly the same type as the message receiver. I guess if either the receiver type or the result type wasn't represented as i8* then the IRBuilder would have crashed.

If we permitted converting say messaging (int*)retain to a call to objc_retain then the bit cast would be needed. Would you like me to permit this change on functions returning anything other than isObjCObjectPointerType(), eg, change that to "isAnyPointerType()"?

The IR type for an AST type satisfying isObjCObjectPointerType() isn't always i8*; in particular, that's not true when the receiver has a concrete class type.

A test case here would be something like:

@interface Foo

• (id) retain;

@end

...

id test(Foo *foo) {

return [foo retain];

}

Here the receiver type will be something like %struct.Foo* and the expected return type will be i8*.

[pete]

Thanks for the example John. I understand what you mean now.

I've added this piece to the test case which verifies that the following IR has the correct bit cast in it. Similarly added cases for alloc and autorelease.

@class A;
@interface B

• (A*) retain;

@end

A* test_retain_class_ptr(B *b) {

return [b retain];

}

define %1* @test_retain_class_ptr(%2* %b) #0 {
entry:

%b.addr = alloca %2*, align 8
store %2* %b, %2** %b.addr, align 8
%0 = load %2*, %2** %b.addr, align 8
%1 = bitcast %2* %0 to i8*
%2 = call i8* @objc_retain(i8* %1) #2
%3 = bitcast i8* %2 to %1*
ret %1* %3

}

[rjmccall]

Can you find where that bitcast is being added? I know that different parts of IRGen are differently sensitive to types — it's possible that the return code is one of those more-permissive places.

[pete]

In D14737#375735, @rjmccall wrote:

Can you find where that bitcast is being added? I know that different parts of IRGen are differently sensitive to types — it's possible that the return code is one of those more-permissive places.

Sure, will do.

I should say that the bit cast here is my doing. I should have said that I added code to emitARCValueOperation which optionally takes a return type to cast to, instead of always casting to the receiver type as you noted it was doing before. But as you point out, even without that change, the IR is still getting bit casts when needed.

[rjmccall]

Ah, okay, if you changed it to cast explicitly, that's all I was concerned about.

[pete]

In D14737#375739, @rjmccall wrote:

Ah, okay, if you changed it to cast explicitly, that's all I was concerned about.

Cool. Thanks. Any other concerns or does this look good to you?

[rjmccall]

Yes, LGTM.

cfe/trunk/include/clang/Basic/ObjCRuntime.h

bool hasNativeARC() const {
 
     case GCC: return false;
     case GNUstep: return getVersion() >= VersionTuple(1, 6);
     case ObjFW: return true;
     }
     llvm_unreachable("bad kind");
   }
 
+  /// Does this runtime provide ARC entrypoints that are likely to be faster
+  /// than an ordinary message send of the appropriate selector?
+  ///
+  /// The ARC entrypoints are guaranteed to be equivalent to just sending the
+  /// corresponding message.  If the entrypoint is implemented naively as just a
+  /// message send, using it is a trade-off: it sacrifices a few cycles of
+  /// overhead to save a small amount of code.  However, it's possible for
+  /// runtimes to detect and special-case classes that use "standard"
+  /// retain/release behavior; if that's dynamically a large proportion of all
+  /// retained objects, using the entrypoint will also be faster than using a
+  /// message send.
+  ///
+  /// When this method returns true, Clang will turn non-super message sends of
+  /// certain selectors into calls to the correspond entrypoint:
+  ///   retain => objc_retain
+  ///   release => objc_release
+  bool shouldUseARCFunctionsForRetainRelease() const {
+    switch (getKind()) {
+    case FragileMacOSX:
+      return false;
+    case MacOSX:
+      return getVersion() >= VersionTuple(10, 10);
+    case iOS:
+      return getVersion() >= VersionTuple(8);
+    case WatchOS:
+      return true;
+
+    case GCC:
+      return false;
+    case GNUstep:
+      return false;
+    case ObjFW:
+      return false;
+    }
+    llvm_unreachable("bad kind");
+  }
+
+  /// Does this runtime provide entrypoints that are likely to be faster
+  /// than an ordinary message send of the "alloc" selector?
+  ///
+  /// The "alloc" entrypoint is guaranteed to be equivalent to just sending the
+  /// corresponding message.  If the entrypoint is implemented naively as just a
+  /// message send, using it is a trade-off: it sacrifices a few cycles of
+  /// overhead to save a small amount of code.  However, it's possible for
+  /// runtimes to detect and special-case classes that use "standard"
+  /// alloc behavior; if that's dynamically a large proportion of all
+  /// objects, using the entrypoint will also be faster than using a message
+  /// send.
+  ///
+  /// When this method returns true, Clang will turn non-super message sends of
+  /// certain selectors into calls to the correspond entrypoint:
+  ///   alloc => objc_alloc
+  bool shouldUseRuntimeFunctionsForAlloc() const {
+    switch (getKind()) {
+    case FragileMacOSX:
+      return false;
+    case MacOSX:
+      return getVersion() >= VersionTuple(10, 10);
+    case iOS:
+      return getVersion() >= VersionTuple(8);
+    case WatchOS:
+      return true;
+
+    case GCC:
+      return false;
+    case GNUstep:
+      return false;
+    case ObjFW:
+      return false;
+    }
+    llvm_unreachable("bad kind");
+  }
+
   /// \brief Does this runtime supports optimized setter entrypoints?
   bool hasOptimizedSetter() const {
     switch (getKind()) {
       case MacOSX:
         return getVersion() >= VersionTuple(10, 8);
       case iOS:
         return (getVersion() >= VersionTuple(6));
       case WatchOS:

cfe/trunk/include/clang/Driver/Options.td

 def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>;
 def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>;
 def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>;
 def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>;
 def fno_zero_initialized_in_bss : Flag<["-"], "fno-zero-initialized-in-bss">, Group<f_Group>;
 def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Synthesize retain and release calls for Objective-C pointers">;
 def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>;
+def fobjc_convert_messages_to_runtime_calls :
+  Flag<["-"], "fobjc-convert-messages-to-runtime-calls">, Group<f_Group>;
+def fno_objc_convert_messages_to_runtime_calls :
+  Flag<["-"], "fno-objc-convert-messages-to-runtime-calls">, Group<f_Group>, Flags<[CC1Option]>;
 def fobjc_arc_exceptions : Flag<["-"], "fobjc-arc-exceptions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use EH-safe code when synthesizing retains and releases in -fobjc-arc">;
 def fno_objc_arc_exceptions : Flag<["-"], "fno-objc-arc-exceptions">, Group<f_Group>;
 def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>;
 def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
 def fobjc_exceptions: Flag<["-"], "fobjc-exceptions">, Group<f_Group>,
   HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>;
 def fapplication_extension : Flag<["-"], "fapplication-extension">,

cfe/trunk/include/clang/Frontend/CodeGenOptions.def

 CODEGENOPT(NoSignedZeros     , 1, 0) ///< Allow ignoring the signedness of FP zero
 CODEGENOPT(ReciprocalMath    , 1, 0) ///< Allow FP divisions to be reassociated.
 CODEGENOPT(NoInline          , 1, 0) ///< Set when -fno-inline is enabled.
                                      ///< Disables use of the inline keyword.
 CODEGENOPT(NoNaNsFPMath      , 1, 0) ///< Assume FP arguments, results not NaN.
 CODEGENOPT(NoZeroInitializedInBSS , 1, 0) ///< -fno-zero-initialized-in-bss.
 /// \brief Method of Objective-C dispatch to use.
 ENUM_CODEGENOPT(ObjCDispatchMethod, ObjCDispatchMethodKind, 2, Legacy) 
+/// Replace certain message sends with calls to ObjC runtime entrypoints
+CODEGENOPT(ObjCConvertMessagesToRuntimeCalls , 1, 1)
 CODEGENOPT(OmitLeafFramePointer , 1, 0) ///< Set when -momit-leaf-frame-pointer is
                                         ///< enabled.
 VALUE_CODEGENOPT(OptimizationLevel, 2, 0) ///< The -O[0-3] option specified.
 VALUE_CODEGENOPT(OptimizeSize, 2, 0) ///< If -Os (==1) or -Oz (==2) is specified.
 
 /// \brief Choose profile instrumenation kind or no instrumentation.
 ENUM_CODEGENOPT(ProfileInstr, ProfileInstrKind, 2, ProfileNone)
 /// \brief Choose profile kind for PGO use compilation.

cfe/trunk/lib/CodeGen/CGObjC.cpp

if (CE->getCastKind() == CK_LValueToRValue) {
       if (CE->getSubExpr()->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
         return CE->getSubExpr();
     }
   }
 
   return nullptr;
 }
 
+/// The ObjC runtime may provide entrypoints that are likely to be faster
+/// than an ordinary message send of the appropriate selector.
+///
+/// The entrypoints are guaranteed to be equivalent to just sending the
+/// corresponding message.  If the entrypoint is implemented naively as just a
+/// message send, using it is a trade-off: it sacrifices a few cycles of
+/// overhead to save a small amount of code.  However, it's possible for
+/// runtimes to detect and special-case classes that use "standard"
+/// retain/release behavior; if that's dynamically a large proportion of all
+/// retained objects, using the entrypoint will also be faster than using a
+/// message send.
+///
+/// If the runtime does support a required entrypoint, then this method will
+/// generate a call and return the resulting value.  Otherwise it will return
+/// None and the caller can generate a msgSend instead.
+static Optional<llvm::Value *>
+tryGenerateSpecializedMessageSend(CodeGenFunction &CGF, QualType ResultType,
+                                  llvm::Value *Receiver, Selector Sel,
+                                  const ObjCMethodDecl *method) {
+  auto &CGM = CGF.CGM;
+  if (!CGM.getCodeGenOpts().ObjCConvertMessagesToRuntimeCalls)
+    return None;
+
+  auto &Runtime = CGM.getLangOpts().ObjCRuntime;
+  switch (Sel.getMethodFamily()) {
+  case OMF_alloc:
+    // Make sure the name is exactly 'alloc'.  All methods with that
+    // prefix are identified as OMF_alloc but we only want to call the
+    // runtime for this version.
+    if (Runtime.shouldUseRuntimeFunctionsForAlloc() && Sel.isUnarySelector() &&
+        Sel.getNameForSlot(0) == "alloc" &&
+        ResultType->isObjCObjectPointerType())
+      return CGF.EmitObjCAlloc(Receiver, CGF.ConvertType(ResultType));
+    break;
+
+  case OMF_autorelease:
+    if (ResultType->isObjCObjectPointerType() &&
+        CGM.getLangOpts().getGC() == LangOptions::NonGC &&
+        Runtime.shouldUseARCFunctionsForRetainRelease())
+      return CGF.EmitARCAutorelease(Receiver, CGF.ConvertType(ResultType));
+    break;
+
+  case OMF_retain:
+    if (ResultType->isObjCObjectPointerType() &&
+        CGM.getLangOpts().getGC() == LangOptions::NonGC &&
+        Runtime.shouldUseARCFunctionsForRetainRelease())
+      return CGF.EmitARCRetainNonBlock(Receiver, CGF.ConvertType(ResultType));
+    break;
+
+  case OMF_release:
+    if (ResultType->isVoidType() &&
+        CGM.getLangOpts().getGC() == LangOptions::NonGC &&
+        Runtime.shouldUseARCFunctionsForRetainRelease()) {
+      CGF.EmitARCRelease(Receiver, ARCPreciseLifetime);
+      return nullptr;
+    }
+    break;
+  default:
+    break;
+  }
+  return None;
+}
+
 RValue CodeGenFunction::EmitObjCMessageExpr(const ObjCMessageExpr *E,
                                             ReturnValueSlot Return) {
   // Only the lookup mechanism and first two arguments of the method
   // implementation vary between runtimes.  We can get the receiver and
   // arguments in generic code.
 
   bool isDelegateInit = E->isDelegateInitCall();
 
result = Runtime.GenerateMessageSendSuper(*this, Return, ResultType,
                                               E->getSelector(),
                                               OMD->getClassInterface(),
                                               isCategoryImpl,
                                               Receiver,
                                               isClassMessage,
                                               Args,
                                               method);
   } else {
+    // Call runtime methods directly if we can.
+    if (Optional<llvm::Value *> SpecializedResult =
+            tryGenerateSpecializedMessageSend(*this, ResultType, Receiver,
+                                              E->getSelector(), method)) {
+      result = RValue::get(SpecializedResult.getValue());
+    } else {
       result = Runtime.GenerateMessageSend(*this, Return, ResultType,
-                                         E->getSelector(),
-                                         Receiver, Args, OID,
-                                         method);
+                                           E->getSelector(), Receiver, Args,
+                                           OID, method);
+    }
   }
 
   // For delegate init calls in ARC, implicitly store the result of
   // the call back into self.  This takes ownership of the value.
   if (isDelegateInit) {
     Address selfAddr =
       GetAddrOfLocalVar(cast<ObjCMethodDecl>(CurCodeDecl)->getSelfDecl());
     llvm::Value *newSelf = result.getScalarVal();
static llvm::Constant *createARCRuntimeFunction(CodeGenModule &CGM,
   return fn;
 }
 
 /// Perform an operation having the signature
 ///   i8* (i8*)
 /// where a null input causes a no-op and returns null.
 static llvm::Value *emitARCValueOperation(CodeGenFunction &CGF,
                                           llvm::Value *value,
+                                          llvm::Type *returnType,
                                           llvm::Constant *&fn,
                                           StringRef fnName,
                                           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);
   }
 
   // Cast the argument to 'id'.
-  llvm::Type *origType = value->getType();
+  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.
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,
+llvm::Value *CodeGenFunction::EmitARCRetainNonBlock(llvm::Value *value,
+                                                    llvm::Type *returnType) {
+  return emitARCValueOperation(*this, value, returnType,
                                CGM.getObjCEntrypoints().objc_retain,
                                "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,
+    = emitARCValueOperation(*this, value, nullptr,
                             CGM.getObjCEntrypoints().objc_retainBlock,
                             "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)) {

 /// Retain the given object which is the result of a function call.
 ///   call i8* \@objc_retainAutoreleasedReturnValue(i8* %value)
 ///
 /// Yes, this function name is one character away from a different
 /// call with completely different semantics.
 llvm::Value *
 CodeGenFunction::EmitARCRetainAutoreleasedReturnValue(llvm::Value *value) {
   emitAutoreleasedReturnValueMarker(*this);
-  return emitARCValueOperation(*this, value,
+  return emitARCValueOperation(*this, value, nullptr,
               CGM.getObjCEntrypoints().objc_retainAutoreleasedReturnValue,
                                "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 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,
+  return emitARCValueOperation(*this, value, nullptr,
               CGM.getObjCEntrypoints().objc_unsafeClaimAutoreleasedReturnValue,
                                "objc_unsafeClaimAutoreleasedReturnValue");
 }
 
 /// Release the given object.
 ///   call void \@objc_release(i8* %value)
 void CodeGenFunction::EmitARCRelease(llvm::Value *value,
                                      ARCPreciseLifetime_t precise) {
llvm::Value *CodeGenFunction::EmitARCStoreStrong(LValue dst,
   // Finally, release the old value.
   EmitARCRelease(oldValue, dst.isARCPreciseLifetime());
 
   return newValue;
 }
 
 /// Autorelease the given object.
 ///   call i8* \@objc_autorelease(i8* %value)
-llvm::Value *CodeGenFunction::EmitARCAutorelease(llvm::Value *value) {
-  return emitARCValueOperation(*this, value,
+llvm::Value *CodeGenFunction::EmitARCAutorelease(llvm::Value *value,
+                                                 llvm::Type *resultType) {
+  return emitARCValueOperation(*this, value, resultType,
                                CGM.getObjCEntrypoints().objc_autorelease,
                                "objc_autorelease");
 }
 
 /// Autorelease the given object.
 ///   call i8* \@objc_autoreleaseReturnValue(i8* %value)
 llvm::Value *
 CodeGenFunction::EmitARCAutoreleaseReturnValue(llvm::Value *value) {
-  return emitARCValueOperation(*this, value,
+  return emitARCValueOperation(*this, value, nullptr,
                             CGM.getObjCEntrypoints().objc_autoreleaseReturnValue,
                                "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,
+  return emitARCValueOperation(*this, value, nullptr,
                      CGM.getObjCEntrypoints().objc_retainAutoreleaseReturnValue,
                                "objc_retainAutoreleaseReturnValue",
                                /*isTailCall*/ true);
 }
 
 /// Do a fused retain/autorelease of the given object.
 ///   call i8* \@objc_retainAutorelease(i8* %value)
 /// or
llvm::Value *CodeGenFunction::EmitARCRetainAutorelease(QualType type,
   value = EmitARCAutorelease(value);
   return Builder.CreateBitCast(value, origType);
 }
 
 /// 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,
+  return emitARCValueOperation(*this, value, nullptr,
                                CGM.getObjCEntrypoints().objc_retainAutorelease,
                                "objc_retainAutorelease");
 }
 
 /// i8* \@objc_loadWeak(i8** %addr)
 /// Essentially objc_autorelease(objc_loadWeakRetained(addr)).
 llvm::Value *CodeGenFunction::EmitARCLoadWeak(Address addr) {
   return emitARCLoadOperation(*this, addr,
llvm::Value *CodeGenFunction::EmitObjCMRRAutoreleasePoolPush() {
   Selector InitSel = getContext().Selectors.getSelector(0, &II);
   RValue InitRV =
     Runtime.GenerateMessageSend(*this, ReturnValueSlot(),
                                 getContext().getObjCIdType(),
                                 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,
+                               CGM.getObjCEntrypoints().objc_alloc,
+                               "objc_alloc");
+}
+
 /// 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;
   CGM.getObjCRuntime().GenerateMessageSend(*this, ReturnValueSlot(),
                               getContext().VoidTy, DrainSel, Arg, Args); 

cfe/trunk/lib/CodeGen/CodeGenFunction.h

public:
   void EmitARCMoveWeak(Address dst, Address src);
   llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value);
   llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value);
   llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
                                   bool resultIgnored);
   llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value,
                                       bool resultIgnored);
   llvm::Value *EmitARCRetain(QualType type, llvm::Value *value);
-  llvm::Value *EmitARCRetainNonBlock(llvm::Value *value);
+  llvm::Value *EmitARCRetainNonBlock(llvm::Value *value,
+                                     llvm::Type *returnType = nullptr);
   llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory);
   void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise);
   void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
-  llvm::Value *EmitARCAutorelease(llvm::Value *value);
+  llvm::Value *EmitARCAutorelease(llvm::Value *value,
+                                  llvm::Type *returnType = nullptr);
   llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value);
   llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value);
   llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value);
   llvm::Value *EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value);
 
   std::pair<LValue,llvm::Value*>
   EmitARCStoreAutoreleasing(const BinaryOperator *e);
   std::pair<LValue,llvm::Value*>
   EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
   std::pair<LValue,llvm::Value*>
   EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored);
 
+  llvm::Value *EmitObjCAlloc(llvm::Value *value,
+                             llvm::Type *returnType = nullptr);
   llvm::Value *EmitObjCThrowOperand(const Expr *expr);
   llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
   llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
 
   llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
   llvm::Value *EmitARCReclaimReturnedObject(const Expr *e,
                                             bool allowUnsafeClaim);
   llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);

cfe/trunk/lib/CodeGen/CodeGenModule.h

bool operator<(const OrderGlobalInits &RHS) const {
     return std::tie(priority, lex_order) <
            std::tie(RHS.priority, RHS.lex_order);
   }
 };
 
 struct ObjCEntrypoints {
   ObjCEntrypoints() { memset(this, 0, sizeof(*this)); }
 
-    /// void objc_autoreleasePoolPop(void*);
+  /// void objc_alloc(id);
+  llvm::Constant *objc_alloc;
+
   llvm::Constant *objc_autoreleasePoolPop;
 
   /// void *objc_autoreleasePoolPush(void);
   llvm::Constant *objc_autoreleasePoolPush;
 
   /// id objc_autorelease(id);
   llvm::Constant *objc_autorelease;
 

cfe/trunk/lib/Driver/Tools.cpp

if (ARC) {
     // We define off for Objective-CC, on for Objective-C++.
     if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
                      options::OPT_fno_objc_arc_exceptions,
                      /*default*/ types::isCXX(InputType)))
       CmdArgs.push_back("-fobjc-arc-exceptions");
 
   }
 
+  // Allow the user to control whether messages can be converted to runtime
+  // functions.
+  if (types::isObjC(InputType)) {
+    auto *Arg = Args.getLastArg(
+        options::OPT_fobjc_convert_messages_to_runtime_calls,
+        options::OPT_fno_objc_convert_messages_to_runtime_calls);
+    if (Arg &&
+        Arg->getOption().matches(
+            options::OPT_fno_objc_convert_messages_to_runtime_calls))
+      CmdArgs.push_back("-fno-objc-convert-messages-to-runtime-calls");
+  }
+
   // -fobjc-infer-related-result-type is the default, except in the Objective-C
   // rewriter.
   if (rewriteKind != RK_None)
     CmdArgs.push_back("-fno-objc-infer-related-result-type");
 
   // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
   // takes precedence.
   const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

if (Method == ~0U) {
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
       Success = false;
     } else {
       Opts.setObjCDispatchMethod(
         static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
     }
   }
 
+  if (Args.hasArg(OPT_fno_objc_convert_messages_to_runtime_calls))
+    Opts.ObjCConvertMessagesToRuntimeCalls = 0;
+
   Opts.EmulatedTLS =
       Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
 
   if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
     StringRef Name = A->getValue();
     unsigned Model = llvm::StringSwitch<unsigned>(Name)
         .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
         .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)

cfe/trunk/test/CodeGenObjC/convert-messages-to-runtime-calls.m

+// RUN: %clang_cc1 -fobjc-runtime=macosx-10.10.0 -emit-llvm -o - %s -fno-objc-convert-messages-to-runtime-calls | FileCheck %s --check-prefix=MSGS
+// RUN: %clang_cc1 -fobjc-runtime=macosx-10.10.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=CALLS
+// RUN: %clang_cc1 -fobjc-runtime=macosx-10.9.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=MSGS
+// RUN: %clang_cc1 -fobjc-runtime=macosx-fragile-10.10.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=MSGS
+// Make sure we don't do calls to retain/release when using GC.
+// RUN: %clang_cc1 -fobjc-runtime=macosx-10.10.0 -emit-llvm -o - %s -fobjc-gc | FileCheck %s --check-prefix=GC
+// RUN: %clang_cc1 -fobjc-runtime=ios-8.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=CALLS
+// RUN: %clang_cc1 -fobjc-runtime=ios-7.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=MSGS
+// Note: This line below is for tvos for which the driver passes through to use the ios9.0 runtime.
+// RUN: %clang_cc1 -fobjc-runtime=ios-9.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=CALLS
+// RUN: %clang_cc1 -fobjc-runtime=watchos-2.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=CALLS
+
+@interface NSObject
++ (id)alloc;
++ (id)alloc2;
+- (id)init;
+- (id)retain;
+- (void)release;
+- (id)autorelease;
+@end
+
+@interface NSString : NSObject
++ (void)retain_self;
+- (void)retain_super;
+@end
+
+// CHECK-LABEL: define {{.*}}void @test1
+void test1(id x) {
+  // MSGS: {{call.*@objc_msgSend}}
+  // MSGS: {{call.*@objc_msgSend}}
+  // MSGS: {{call.*@objc_msgSend}}
+  // MSGS: {{call.*@objc_msgSend}}
+  // CALLS: {{call.*@objc_alloc}}
+  // CALLS: {{call.*@objc_retain}}
+  // CALLS: {{call.*@objc_release}}
+  // CALLS: {{call.*@objc_autorelease}}
+  // GC: {{call.*@objc_alloc}}
+  // GC: {{call.*@objc_msgSend}}
+  // GC: {{call.*@objc_msgSend}}
+  // GC: {{call.*@objc_msgSend}}
+  [NSObject alloc];
+  [x retain];
+  [x release];
+  [x autorelease];
+}
+
+// CHECK-LABEL: define {{.*}}void @test2
+void test2() {
+  // MSGS: {{call.*@objc_msgSend}}
+  // CALLS: {{call.*@objc_msgSend}}
+  // GC: {{call.*@objc_msgSend}}
+  // Make sure alloc has the correct name and number of types.
+  [NSObject alloc2];
+}
+
+@class A;
+@interface B
++ (A*) alloc;
+- (A*) retain;
+- (A*) autorelease;
+@end
+
+// Make sure we get a bitcast on the return type as the
+// call will return i8* which we have to cast to A*
+// CHECK-LABEL: define {{.*}}void @test_alloc_class_ptr
+A* test_alloc_class_ptr() {
+  // CALLS: {{call.*@objc_alloc}}
+  // CALLS-NEXT: bitcast i8*
+  // CALLS-NEXT: ret
+  return [B alloc];
+}
+
+// Make sure we get a bitcast on the return type as the
+// call will return i8* which we have to cast to A*
+// CHECK-LABEL: define {{.*}}void @test_retain_class_ptr
+A* test_retain_class_ptr(B *b) {
+  // CALLS: {{call.*@objc_retain}}
+  // CALLS-NEXT: bitcast i8*
+  // CALLS-NEXT: ret
+  return [b retain];
+}
+
+// Make sure we get a bitcast on the return type as the
+// call will return i8* which we have to cast to A*
+// CHECK-LABEL: define {{.*}}void @test_autorelease_class_ptr
+A* test_autorelease_class_ptr(B *b) {
+  // CALLS: {{call.*@objc_autorelease}}
+  // CALLS-NEXT: bitcast i8*
+  // CALLS-NEXT: ret
+  return [b autorelease];
+}
+
+@interface C
+- (float) retain;
+@end
+
+// Make sure we use a message and not a call as the return type is
+// not a pointer type.
+// CHECK-LABEL: define {{.*}}void @test_cannot_message_return_float
+float test_cannot_message_return_float(C *c) {
+  // MSGS: {{call.*@objc_msgSend}}
+  // CALLS: {{call.*@objc_msgSend}}
+  // GC: {{call.*@objc_msgSend}}
+  return [c retain];
+}
+
+@implementation NSString
+
+// Make sure we can convert a message to a dynamic receiver to a call
+// CHECK-LABEL: define {{.*}}void @retain_self
++ (void)retain_self {
+  // MSGS: {{call.*@objc_msgSend}}
+  // CALLS: {{call.*@objc_retain}}
+  // GC: {{call.*@objc_msgSend}}
+  [self retain];
+}
+
+// Make sure we never convert a message to super to a call
+// CHECK-LABEL: define {{.*}}void @retain_super
+- (void)retain_super {
+  // MSGS: {{call.*@objc_msgSend}}
+  // CALLS: {{call.*@objc_msgSend}}
+  // GC: {{call.*@objc_msgSend}}
+  [super retain];
+}
+
+@end
+
+

cfe/trunk/test/Driver/objc-convert-messages-to-runtime-calls.m

+// RUN: %clang %s -### -o %t.o 2>&1 -fsyntax-only -fobjc-convert-messages-to-runtime-calls -fno-objc-convert-messages-to-runtime-calls -target x86_64-apple-macosx10.10.0 | FileCheck  %s --check-prefix=DISABLE
+// RUN: %clang %s -### -o %t.o 2>&1 -fsyntax-only -fno-objc-convert-messages-to-runtime-calls -fobjc-convert-messages-to-runtime-calls -target x86_64-apple-macosx10.10.0 | FileCheck  %s --check-prefix=ENABLE
+
+// Check that we pass fobjc-convert-messages-to-runtime-calls only when supported, and not explicitly disabled.
+
+// DISABLE: "-fno-objc-convert-messages-to-runtime-calls"
+// ENABLE-NOT: "-fno-objc-convert-messages-to-runtime-calls"