[ObjC] Replace uses of the argument of a call to objc_autorelease with the result in MRR

[ahatanak]

Summary

This is needed to enable performing tail-call optimization on calls to objc_autorelease in MRR, which enables objc_autorelease to perform the retainRV/ autoreleaseRV handshake that keeps the returned object out of the autorelease pool.

With this patch, the backend can tail-call the call to objc_autorelease in function bar in the code below.

// We currently tail call the call to `objc_autorelease` in `foo`
NSObject *foo(void) {
  NSObject *t = [NSObject new];
  return [t autorelease];
}

// We currently don't tail-call the call to `objc_autorelease` in `bar` because its result isn't used by the return instruction.
//
// %call = tail call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %0, i8* %1)
// %2 = bitcast i8* %call to %0*
// %3 = tail call i8* @objc_autorelease(i8* %call) #2
// ret %0* %2

NSObject *bar(void) {
  NSObject *t = [NSObject new];
  [t autorelease];
  return t;
}

rdar://problem/50353574

[ahatanak]

Someone reminded me that I could replace the MRR call to objc_autorelease with the ARC call to objc_autoreleaseReturnValue in the front-end. I'm going to try that idea.

[rjmccall]

The assumption that these methods return the receiver is not true without additional semantic assumptions about these methods, so the current behavior of unconditionally turning [x autorelease] into objc_autorelease(x), x seems quite broken.

[ahatanak]

In D61808#1505023, @rjmccall wrote:

The assumption that these methods return the receiver is not true without additional semantic assumptions about these methods, so the current behavior of unconditionally turning [x autorelease] into objc_autorelease(x), x seems quite broken.

Because it's possible to override an autorelease method and make the method return something other than the passed argument, for example?

If it's not possible to assume that the method returns the passed argument in MRR, the direction of this patch and https://reviews.llvm.org/D61970 is completely wrong.

[rjmccall]

In D61808#1505544, @ahatanak wrote:

In D61808#1505023, @rjmccall wrote:

The assumption that these methods return the receiver is not true without additional semantic assumptions about these methods, so the current behavior of unconditionally turning [x autorelease] into objc_autorelease(x), x seems quite broken.

Because it's possible to override an autorelease method and make the method return something other than the passed argument, for example?

If it's not possible to assume that the method returns the passed argument in MRR, the direction of this patch and https://reviews.llvm.org/D61970 is completely wrong.

Well, objc_retain and objc_autorelease (and objc_release, trivially) do return the normal return value of the message send in MRR, so assuming that's preserved in the IR, you just need to use that as the expression result. But if the backend's going to unconditionally optimize the intrinsics based on the assumption that those values are the same, that's problematic, just as it would be problematic for it to do ARC-approved reordering on intrinsics emitted for MRR.

[ahatanak]

In D61808#1505608, @rjmccall wrote:

In D61808#1505544, @ahatanak wrote:

In D61808#1505023, @rjmccall wrote:

The assumption that these methods return the receiver is not true without additional semantic assumptions about these methods, so the current behavior of unconditionally turning [x autorelease] into objc_autorelease(x), x seems quite broken.

Because it's possible to override an autorelease method and make the method return something other than the passed argument, for example?

If it's not possible to assume that the method returns the passed argument in MRR, the direction of this patch and https://reviews.llvm.org/D61970 is completely wrong.

Well, objc_retain and objc_autorelease (and objc_release, trivially) do return the normal return value of the message send in MRR, so assuming that's preserved in the IR, you just need to use that as the expression result. But if the backend's going to unconditionally optimize the intrinsics based on the assumption that those values are the same, that's problematic, just as it would be problematic for it to do ARC-approved reordering on intrinsics emitted for MRR.

Okay, that means it's not legal to tail-call the call to objc_autorelease in function bar in the summary since we can't assume t is the same as the result of [t autorelease]. Also, it's not correct to emit the calls to objc_autoreleaseReturnValue and objc_retainAutoreleasedReturnValue as intrinsics calls and let the ARC optimizer and ARC contract pass optimize them as if they were compiled in ARC as I did in https://reviews.llvm.org/D61970.

[rjmccall]

Oh, yes, that's correct, at least under base ObjC rules.

Now, we *are* talking here about making some other higher-level assumptions about retain/release/autorelease that already exceed base ObjC rules. Turning autorelease into autoreleaseRV isn't sound under base ObjC rules because nothing in base ObjC permits us to not do a message send that's clearly called for in the source; but nonetheless we do want to do some optimizations like that even in MRR, and we think that's tolerable in part because retain and release are already special in ObjC (because of retain properties and block captures). So maybe it's not unreasonable to consider this assumption about the return value of retain and autorelease to be part of the higher-level semantics we want to assume for these messages.

However, (1) we need to carefully document those higher-level assumptions and (2) we need to make sure they're all disabled by this same no-builtin-retain-release flag, which means propagating information to the optimizer somehow (by just emitting non-builtin messages as normal message sends if necessary).

[ahatanak]

We discussed this before, but we already break the base ObjC rules since the runtime elides the autorelease message send in MRR when it's possible to perform the retainRV/autoreleaseRV optimization, which only happens when the caller (or a caller higher up in the call-chain if it's tail-called) is compiled with ARC. IIUC, the only semantic change we''ll be making if we emit an objc_autoreleaseReturnValue call instead of an objc_autorelease call is that we no longer guarantee that the message send will happen when the class overrides the autorelease method, which we do guarantee with calls to objc_autorelease (see objc_object::autorelease and objc_object::rootAutorelease in the link below).

https://opensource.apple.com/source/objc4/objc4-750/runtime/objc-object.h.auto.html

If we also emit an objc_retainAutoreleasedReturnValue call instead of an objc_retain call, the retainRV/autoreleaseRV handshake will happen more frequently since now the caller doesn't have to be compiled in ARC in order for it to happen.

[rjmccall]

I don't know what you mean. Currently, if the callee tail-calls autorelease (and necessarily this has to be MRR code), we perform an ordinary message send of autorelease. It happens to be the case that the standard implementation of autorelease will allow the autorelease to be reclaimed, but nothing about that choice is in any way non-standard on the MRR side.

[ahatanak]

IIUC, this is what happens when there is an autorelease message send in the source code:

1. When there is an autorelease message send, clang's IRGen converts it to a call to objc_autorelease. This is the result of Pete's work that was committed a few months ago.
2. objc_autorelease calls objc_object::autorelease.
3. objc_object::autorelease calls rootAutorelease if !ISA()->hasCustomRR() is true. Otherwise, it sends an autorelease message.
4. rootAutorelease returns (id)this if prepareOptimizedReturn(ReturnAtPlus1) is true.

So the autorelease message isn't sent if !ISA()->hasCustomRR(). Doesn't that mean it is breaking the basic ObjC rules?

[rjmccall]

No, because hasCustomRR is set whenever the method implementation isn't the standard -[NSObject autorelease] implementation. In other words, this is just inlining the standard implementation when it's dynamically known that the dispatch would end up there anyway.

[ahatanak]

Okay, I see. The result of calling rootAutorelease when !ISA()->hasCustomRR() is true is the same as a message send, so it doesn't break the basic rules.

[rjmccall]

Right, exactly.

[ahatanak]

This patch is based on the assumption that the argument and the return value of objc_autorelease are equal, which isn't always true in MRR.

lib/Transforms/ObjCARC/ObjCARCContract.cpp

 //===- ObjCARCContract.cpp - ObjC ARC Optimization ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// This file defines late ObjC ARC optimizations. ARC stands for Automatic
 /// Reference Counting and is a system for managing reference counts for objects
 /// in Objective C.
 ///
 /// This specific file mainly deals with ``contracting'' multiple lower level
 /// operations into singular higher level operations through pattern matching.
 ///
+/// This file also replaces uses of the argument of a call to objc_autorelease
+/// in MRR with the result to enable performing tall-call optimization on the
+/// call when the call result is returned by the calling function.
+///
 /// WARNING: This file knows about certain library functions. It recognizes them
 /// by name, and hardwires knowledge of their semantics.
 ///
 /// WARNING: This file knows about how certain Objective-C library functions are
 /// used. Naive LLVM IR transformations which would otherwise be
 /// behavior-preserving may break these assumptions.
 ///
 //===----------------------------------------------------------------------===//
case ARCInstKind::User:
     if (isa<AllocaInst>(Inst))
       TailOkForStoreStrongs = false;
     return true;
   case ARCInstKind::IntrinsicUser:
     // Remove calls to @llvm.objc.clang.arc.use(...).
     Inst->eraseFromParent();
     return true;
   default:
+    // Replace uses of the argument of a call to objc_autorelease in MRR with
+    // the result to enable performing tail-call optimization on it.
+    if (auto *CI = dyn_cast<CallInst>(Inst))
+      if (Function *Callee = CI->getCalledFunction())
+        return !Callee->getName().equals("objc_autorelease");
     return true;
   }
 }
 
 //===----------------------------------------------------------------------===//
 //                              Top Level Driver
 //===----------------------------------------------------------------------===//
 
void ObjCARCContract::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<AAResultsWrapperPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
   AU.setPreservesCFG();
 }
 
 Pass *llvm::createObjCARCContractPass() { return new ObjCARCContract(); }
 
 bool ObjCARCContract::doInitialization(Module &M) {
-  // If nothing in the Module uses ARC, don't do anything.
-  Run = ModuleHasARC(M);
+  // If nothing in the Module uses ARC or calls objc_autorelease in MRR, don't
+  // do anything.
+  Run = ModuleHasARC(M) || M.getNamedValue("objc_autorelease");
   if (!Run)
     return false;
 
   EP.init(&M);
 
   // Initialize RVInstMarker.
   const char *MarkerKey = "clang.arc.retainAutoreleasedReturnValueMarker";
   RVInstMarker = dyn_cast_or_null<MDString>(M.getModuleFlag(MarkerKey));
 
   return false;
 }

test/Transforms/ObjCARC/contract-replace-arg-use.ll

 ; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
 
+%0 = type opaque
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
 declare i8* @foo1()
 
 ; Check that ARC contraction replaces the function return with the value
 ; returned by @llvm.objc.autoreleaseReturnValue.
 
 ; CHECK-LABEL: define i32* @autoreleaseRVTailCall(
 ; CHECK: %[[V0:[0-9]+]] = tail call i8* @llvm.objc.autoreleaseReturnValue(
bb2:
   %v3 = bitcast i32* %v2 to i8*
   br label %bb3
 bb3:
   %phival = phi i8* [ %v1, %bb1 ], [ %v3, %bb2 ]
   %retval = phi i32* [ %v0, %bb1 ], [ %v2, %bb2 ]
   %v4 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %phival)
   ret i32* %retval
 }
+
+; CHECK-LABEL: define %0* @testAutoreleaseTailCallMRR(
+; CHECK: %[[V1:.*]] = tail call i8* @objc_autorelease(i8* %
+; CHECK: %[[V2:.*]] = bitcast i8* %[[V1]] to %0*
+; CHECK: ret %0* %[[V2]]
+
+define %0* @testAutoreleaseTailCallMRR() {
+  %call = tail call i8* @foo1()
+  %v0 = bitcast i8* %call to %0*
+  %v1 = tail call i8* @objc_autorelease(i8* %call)
+  ret %0* %v0
+}
+
+declare i8* @objc_autorelease(i8*)