Remove the autorelease_return and strong_retain_autoreleased instructions.

There's a buggy SIL verifier check that was previously tautological,
and it turns out that it's violated, apparently harmlessly.  Since it
was already doing nothing, I've commented it out temporarily while
I figure out the right way to fix SILGen to get the invariant right.

Author: rjmccall

docs/ARCOptimization.rst

@@ -15,7 +15,6 @@ Reference Counting Instructions
 ===============================
 
 - strong_retain
-- strong_retain_autoreleased
 - strong_release
 - strong_retain_unowned
 - unowned_retain

docs/SIL.rst

@@ -511,9 +511,19 @@ throughout the execution of the call. This means that any
 argument can be eliminated.
 
 An autoreleased direct result must have a type with a retainable
-pointer representation.  It may have been autoreleased, and the caller
-should take action to reclaim that autorelease with
-``strong_retain_autoreleased``.
+pointer representation.  Autoreleased results are nominally transferred
+at +0, but the runtime takes steps to ensure that a +1 can be safely
+transferred, and those steps require precise code-layout control.
+Accordingly, the SIL pattern for an autoreleased convention looks exactly
+like the SIL pattern for an owned convention, and the extra runtime
+instrumentation is inserted on both sides when the SIL is lowered into
+LLVM IR.  An autoreleased ``apply`` of a function that is defined with
+an autoreleased result has the effect of a +1 transfer of the result.
+An autoreleased ``apply`` of a function that is not defined with
+an autoreleased result has the effect of performing a strong retain in
+the caller.  A non-autoreleased ``apply`` of a function that is defined
+with an autoreleased result has the effect of performing an
+autorelease in the callee.
 
 - The @noescape declaration attribute on Swift parameters (which is valid only
   on parameters of function type, and is implied by the @autoclosure attribute)
@@ -2184,23 +2194,6 @@ strong_retain
 
 Increases the strong retain count of the heap object referenced by ``%0``.
 
-strong_retain_autoreleased
-``````````````````````````
-::
-
-  sil-instruction ::= 'strong_retain_autoreleased' sil-operand
-
-  strong_retain_autoreleased %0 : $T
-  // $T must have a retainable pointer representation
-
-Retains the heap object referenced by ``%0`` using the Objective-C ARC
-"autoreleased return value" optimization. The operand must be the result of an
-``apply`` instruction with an Objective-C method callee, and the
-``strong_retain_autoreleased`` instruction must be first use of the value after
-the defining ``apply`` instruction.
-
-TODO: Specify all the other strong_retain_autoreleased constraints here.
-
 strong_release
 ``````````````
 ::
@@ -3952,23 +3945,6 @@ will be the operand of this ``return`` instruction.
 
 A function must not contain more than one ``return`` instruction.
 
-autorelease_return
-``````````````````
-::
-
-  sil-terminator ::= 'autorelease_return' sil-operand
-
-  autorelease_return %0 : $T
-  // $T must be the return type of the current function, which must be of
-  //   class type
-
-Exits the current function and returns control to the calling function. The
-result of the ``apply`` instruction that invoked the current function will be
-the operand of this ``return`` instruction. The return value is autoreleased
-into the active Objective-C autorelease pool using the "autoreleased return
-value" optimization. The current function must use the ``@cc(objc_method)``
-calling convention.
-
 throw
 `````
 ::

include/swift/SIL/PatternMatch.h

@@ -370,7 +370,6 @@ UNARY_OP_MATCH_WITH_ARG_MATCHER(DeinitExistentialAddrInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ProjectBlockStorageInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(StrongRetainInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(StrongReleaseInst)
-UNARY_OP_MATCH_WITH_ARG_MATCHER(StrongRetainAutoreleasedInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(StrongRetainUnownedInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(UnownedRetainInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(UnownedReleaseInst)
@@ -383,7 +382,6 @@ UNARY_OP_MATCH_WITH_ARG_MATCHER(DeallocBoxInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(DestroyAddrInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(CondFailInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ReturnInst)
-UNARY_OP_MATCH_WITH_ARG_MATCHER(AutoreleaseReturnInst)
 #undef UNARY_OP_MATCH_WITH_ARG_MATCHER
 
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILBuilder.h

@@ -1010,11 +1010,6 @@ class SILBuilder {
     return insert(new (F.getModule())
                       StrongReleaseInst(createSILDebugLocation(Loc), Operand));
   }
-  StrongRetainAutoreleasedInst *
-  createStrongRetainAutoreleased(SILLocation Loc, SILValue Operand) {
-    return insert(new (F.getModule()) StrongRetainAutoreleasedInst(
-        createSILDebugLocation(Loc), Operand));
-  }
   StrongPinInst *createStrongPin(SILLocation Loc, SILValue Operand) {
     return insert(new (F.getModule())
                       StrongPinInst(createSILDebugLocation(Loc), Operand));
@@ -1184,12 +1179,6 @@ class SILBuilder {
         createSILDebugLocation(Loc), ReturnValue));
   }
 
-  AutoreleaseReturnInst *createAutoreleaseReturn(SILLocation Loc,
-                                                 SILValue ReturnValue) {
-    return insertTerminator(new (F.getModule()) AutoreleaseReturnInst(
-        createSILDebugLocation(Loc), ReturnValue));
-  }
-
   ThrowInst *createThrow(SILLocation Loc, SILValue errorValue) {
     return insertTerminator(
         new (F.getModule()) ThrowInst(createSILDebugLocation(Loc), errorValue));

include/swift/SIL/SILCloner.h

@@ -1432,17 +1432,6 @@ SILCloner<ImplClass>::visitStrongRetainInst(StrongRetainInst *Inst) {
                                     getOpValue(Inst->getOperand())));
 }
 
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::
-visitStrongRetainAutoreleasedInst(StrongRetainAutoreleasedInst *Inst) {
-  SILValue OpValue = getOpValue(Inst->getOperand());
-  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  doPostProcess(Inst,
-    getBuilder().createStrongRetainAutoreleased(getOpLocation(Inst->getLoc()),
-                                                OpValue));
-}
-
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitFixLifetimeInst(FixLifetimeInst *Inst) {
@@ -1667,15 +1656,6 @@ SILCloner<ImplClass>::visitReturnInst(ReturnInst *Inst) {
                               getOpValue(Inst->getOperand())));
 }
 
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::visitAutoreleaseReturnInst(AutoreleaseReturnInst *Inst) {
-  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  doPostProcess(Inst,
-    getBuilder().createAutoreleaseReturn(getOpLocation(Inst->getLoc()),
-                                         getOpValue(Inst->getOperand())));
-}
-
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitThrowInst(ThrowInst *Inst) {

include/swift/SIL/SILFunction.h

@@ -517,7 +517,6 @@ class SILFunction
     return std::find_if(begin(), end(),
       [](const SILBasicBlock &BB) -> bool {
         const TermInst *TI = BB.getTerminator();
-        // TODO: We autorelease_return should also be handled here.
         return isa<ReturnInst>(TI);
     });
   }

include/swift/SIL/SILInstruction.h

@@ -3185,18 +3185,6 @@ class StrongRetainInst
       : UnaryInstructionBase(DebugLoc, Operand) {}
 };
 
-/// StrongRetainAutoreleasedInst - Take ownership of the autoreleased return
-/// value of an ObjC method.
-class StrongRetainAutoreleasedInst
-  : public UnaryInstructionBase<ValueKind::StrongRetainAutoreleasedInst,
-                                RefCountingInst, /*HAS_RESULT*/ false>
-{
-  friend class SILBuilder;
-
-  StrongRetainAutoreleasedInst(SILDebugLocation *DebugLoc, SILValue Operand)
-      : UnaryInstructionBase(DebugLoc, Operand) {}
-};
-
 /// StrongReleaseInst - Decrease the strong reference count of an object.
 ///
 /// An object can be destroyed when its strong reference count is
@@ -3665,31 +3653,6 @@ class ReturnInst
   }
 };
 
-/// AutoreleaseReturnInst - Transfer ownership of a value to an ObjC
-/// autorelease pool, and then return the value.
-class AutoreleaseReturnInst
-  : public UnaryInstructionBase<ValueKind::AutoreleaseReturnInst, TermInst,
-                                /*HAS_RESULT*/ false>
-{
-  friend class SILBuilder;
-
-  /// Constructs an AutoreleaseReturnInst representing an autorelease-return
-  /// sequence.
-  ///
-  /// \param DebugLoc The backing AST location.
-  ///
-  /// \param ReturnValue The value to be returned.
-  ///
-  AutoreleaseReturnInst(SILDebugLocation *DebugLoc, SILValue ReturnValue)
-      : UnaryInstructionBase(DebugLoc, ReturnValue) {}
-
-public:
-  SuccessorListTy getSuccessors() {
-    // No Successors.
-    return SuccessorListTy();
-  }
-};
-
 /// ThrowInst - Throw a typed error (which, in our system, is
 /// essentially just a funny kind of return).
 class ThrowInst

include/swift/SIL/SILLocation.h

@@ -399,7 +399,7 @@ class RegularLocation : public SILLocation {
 
 /// Used to represent a return instruction in user code.
 ///
-/// Allowed on an BranchInst, ReturnInst, AutoreleaseReturnInst.
+/// Allowed on an BranchInst, ReturnInst.
 class ReturnLocation : public SILLocation {
 public:
   ReturnLocation(ReturnStmt *RS) : SILLocation(RS, ReturnKind) {}
@@ -423,7 +423,7 @@ class ReturnLocation : public SILLocation {
 /// Used on the instruction that was generated to represent an implicit
 /// return from a function.
 ///
-/// Allowed on an BranchInst, ReturnInst, AutoreleaseReturnInst.
+/// Allowed on an BranchInst, ReturnInst.
 class ImplicitReturnLocation : public SILLocation {
 public:
 
@@ -467,7 +467,7 @@ class ImplicitReturnLocation : public SILLocation {
 ///
 /// This location wraps the call site ASTNode.
 ///
-/// Allowed on any instruction except for ReturnInst, AutoreleaseReturnInst.
+/// Allowed on any instruction except for ReturnInst.
 class InlinedLocation : public SILLocation {
 public:
   InlinedLocation(Expr *CallSite) : SILLocation(CallSite, InlinedKind) {}
@@ -514,7 +514,7 @@ class InlinedLocation : public SILLocation {
 ///
 /// This location wraps the call site ASTNode.
 ///
-/// Allowed on any instruction except for ReturnInst, AutoreleaseReturnInst.
+/// Allowed on any instruction except for ReturnInst.
 class MandatoryInlinedLocation : public SILLocation {
 public:
   MandatoryInlinedLocation(Expr *CallSite) :
@@ -572,7 +572,7 @@ class MandatoryInlinedLocation : public SILLocation {
 /// scope's end location points to the SourceLoc that shows when the operation
 /// is performed at runtime.
 ///
-/// Allowed on any instruction except for ReturnInst, AutoreleaseReturnInst.
+/// Allowed on any instruction except for ReturnInst.
 /// Locations of an inlined destructor should also be represented by this.
 class CleanupLocation : public SILLocation {
 public:

include/swift/SIL/SILNodes.def

@@ -113,8 +113,6 @@ ABSTRACT_VALUE(SILInstruction, ValueBase)
   // Reference Counting
   ABSTRACT_VALUE(RefCountingInst, SILInstruction)
     INST(StrongRetainInst, RefCountingInst, MayHaveSideEffects, DoesNotRelease)
-    INST(StrongRetainAutoreleasedInst, RefCountingInst, MayHaveSideEffects,
-         DoesNotRelease)
     INST(StrongReleaseInst, RefCountingInst, MayHaveSideEffects, MayRelease)
     INST(StrongRetainUnownedInst, RefCountingInst, MayHaveSideEffects,
          DoesNotRelease)
@@ -245,7 +243,6 @@ ABSTRACT_VALUE(SILInstruction, ValueBase)
   ABSTRACT_VALUE(TermInst, SILInstruction)
     TERMINATOR(UnreachableInst, TermInst, None, DoesNotRelease)
     TERMINATOR(ReturnInst, TermInst, None, DoesNotRelease)
-    TERMINATOR(AutoreleaseReturnInst, TermInst, None, DoesNotRelease)
     TERMINATOR(ThrowInst, TermInst, None, DoesNotRelease)
     TERMINATOR(TryApplyInst, TermInst, MayHaveSideEffects, MayRelease)
     TERMINATOR(BranchInst, TermInst, None, DoesNotRelease)

include/swift/SILPasses/Utils/SCCVisitor.h

@@ -131,7 +131,6 @@ class SCCVisitor {
 
     case ValueKind::UnreachableInst:
     case ValueKind::ReturnInst:
-    case ValueKind::AutoreleaseReturnInst:
     case ValueKind::SwitchValueInst:
     case ValueKind::ThrowInst:
       llvm_unreachable("Did not expect terminator that does not have args!");

lib/IRGen/IRGenSIL.cpp

@@ -667,7 +667,6 @@ class IRGenSILFunction :
   void visitStrongUnpinInst(StrongUnpinInst *i);
   void visitStrongRetainInst(StrongRetainInst *i);
   void visitStrongReleaseInst(StrongReleaseInst *i);
-  void visitStrongRetainAutoreleasedInst(StrongRetainAutoreleasedInst *i);
   void visitStrongRetainUnownedInst(StrongRetainUnownedInst *i);
   void visitUnownedRetainInst(UnownedRetainInst *i);
   void visitUnownedReleaseInst(UnownedReleaseInst *i);
@@ -723,7 +722,6 @@ class IRGenSILFunction :
   void visitBranchInst(BranchInst *i);
   void visitCondBranchInst(CondBranchInst *i);
   void visitReturnInst(ReturnInst *i);
-  void visitAutoreleaseReturnInst(AutoreleaseReturnInst *i);
   void visitThrowInst(ThrowInst *i);
   void visitSwitchValueInst(SwitchValueInst *i);
   void visitSwitchEnumInst(SwitchEnumInst *i);
@@ -2170,15 +2168,6 @@ void IRGenSILFunction::visitReturnInst(swift::ReturnInst *i) {
   emitReturnInst(*this, i->getOperand().getType(), result);
 }
 
-void IRGenSILFunction::visitAutoreleaseReturnInst(AutoreleaseReturnInst *i) {
-  Explosion result = getLoweredExplosion(i->getOperand());
-  assert(result.size() == 1 &&
-         "should have one objc pointer value for autorelease_return");
-  Explosion temp;
-  temp.add(emitObjCAutoreleaseReturnValue(*this, result.claimNext()));
-  emitReturnInst(*this, i->getOperand().getType(), temp);
-}
-
 void IRGenSILFunction::visitThrowInst(swift::ThrowInst *i) {
   // Store the exception to the error slot.
   llvm::Value *exn = getLoweredSingletonExplosion(i->getOperand());
@@ -3078,29 +3067,6 @@ void IRGenSILFunction::visitStrongReleaseInst(swift::StrongReleaseInst *i) {
   ti.strongRelease(*this, lowered);
 }
 
-void IRGenSILFunction::
-visitStrongRetainAutoreleasedInst(swift::StrongRetainAutoreleasedInst *i) {
-  Explosion lowered = getLoweredExplosion(i->getOperand());
-  llvm::Value *value = lowered.claimNext();
-  value = emitObjCRetainAutoreleasedReturnValue(*this, value);
-
-  // Overwrite the stored explosion value with the result of
-  // objc_retainAutoreleasedReturnValue.  This is actually
-  // semantically important: if the call result is live across this
-  // call, the backend will have to emit instructions that interfere
-  // with the reclaim optimization.
-  //
-  // This is only sound if the retainAutoreleasedReturnValue
-  // immediately follows the call, but that should be reliably true.
-  //
-  // ...the reclaim here should really be implicit in the SIL calling
-  // convention.
-
-  Explosion out;
-  out.add(value);
-  overwriteLoweredExplosion(i->getOperand(), out);
-}
-
 /// Given a SILType which is a ReferenceStorageType, return the type
 /// info for the underlying reference type.
 static const ReferenceTypeInfo &getReferentTypeInfo(IRGenFunction &IGF,

lib/Parse/ParseSIL.cpp

@@ -1194,7 +1194,6 @@ bool SILParser::parseSILOpcode(ValueKind &Opcode, SourceLoc &OpcodeLoc,
     .Case("witness_method", ValueKind::WitnessMethodInst)
     .Case("apply", ValueKind::ApplyInst)
     .Case("assign", ValueKind::AssignInst)
-    .Case("autorelease_return", ValueKind::AutoreleaseReturnInst)
     .Case("autorelease_value", ValueKind::AutoreleaseValueInst)
     .Case("br", ValueKind::BranchInst)
     .Case("builtin", ValueKind::BuiltinInst)
@@ -1271,7 +1270,6 @@ bool SILParser::parseSILOpcode(ValueKind &Opcode, SourceLoc &OpcodeLoc,
     .Case("strong_pin", ValueKind::StrongPinInst)
     .Case("strong_release", ValueKind::StrongReleaseInst)
     .Case("strong_retain", ValueKind::StrongRetainInst)
-    .Case("strong_retain_autoreleased", ValueKind::StrongRetainAutoreleasedInst)
     .Case("strong_retain_unowned", ValueKind::StrongRetainUnownedInst)
     .Case("strong_unpin", ValueKind::StrongUnpinInst)
     .Case("return", ValueKind::ReturnInst)
@@ -1934,9 +1932,7 @@ bool SILParser::parseSILInstruction(SILBasicBlock *BB) {
   UNARY_INSTRUCTION(StrongPin)
   UNARY_INSTRUCTION(StrongRetain)
   UNARY_INSTRUCTION(StrongRelease)
-  UNARY_INSTRUCTION(StrongRetainAutoreleased)
   UNARY_INSTRUCTION(StrongUnpin)
-  UNARY_INSTRUCTION(AutoreleaseReturn)
   UNARY_INSTRUCTION(StrongRetainUnowned)
   UNARY_INSTRUCTION(UnownedRetain)
   UNARY_INSTRUCTION(UnownedRelease)

lib/SIL/SILPrinter.cpp

@@ -1255,9 +1255,6 @@ class SILPrinter : public SILVisitor<SILPrinter> {
   void visitStrongRetainInst(StrongRetainInst *RI) {
     *this << "strong_retain " << getIDAndType(RI->getOperand());
   }
-  void visitStrongRetainAutoreleasedInst(StrongRetainAutoreleasedInst *RI) {
-    *this << "strong_retain_autoreleased " << getIDAndType(RI->getOperand());
-  }
   void visitStrongReleaseInst(StrongReleaseInst *RI) {
     *this << "strong_release " << getIDAndType(RI->getOperand());
   }
@@ -1337,10 +1334,6 @@ class SILPrinter : public SILVisitor<SILPrinter> {
     *this << "return " << getIDAndType(RI->getOperand());
   }
 
-  void visitAutoreleaseReturnInst(AutoreleaseReturnInst *RI) {
-    *this << "autorelease_return " << getIDAndType(RI->getOperand());
-  }
-  
   void visitThrowInst(ThrowInst *TI) {
     *this << "throw " << getIDAndType(TI->getOperand());
   }