Merge pull request #60665 from gottesmm/pr-946fc9a839dd236549c02b010887103537c3b833

[builtin] Remove "unsafeGuaranteed" and related code since Unmanaged now has an Ownership SSA based implementation that works completely in SILGen.

Author: gottesmm

docs/SIL.rst

@@ -4862,36 +4862,6 @@ into a ``copy_block`` and a ``is_escaping``/``cond_fail``/``destroy_value`` at
 the end of the lifetime of the objective c closure parameter to check whether
 the sentinel closure was escaped.
 
-builtin "unsafeGuaranteed"
-``````````````````````````
-
-::
-
-  sil-instruction := 'builtin' '"unsafeGuaranteed"' '<' sil-type '>' '(' sil-operand')' ':' sil-type
-
-  %1 = builtin "unsafeGuaranteed"<T>(%0 : $T) : ($T, Builtin.Int1)
-  // $T must be of AnyObject type.
-
-Asserts that there exists another reference of the value ``%0`` for the scope
-delineated by the call of this builtin up to the first call of a ``builtin
-"unsafeGuaranteedEnd"`` instruction that uses the second element ``%1.1`` of the
-returned value. If no such instruction can be found nothing can be assumed. This
-assertion holds for uses of the first tuple element of the returned value
-``%1.0`` within this scope. The returned reference value equals the input
-``%0``.
-
-builtin "unsafeGuaranteedEnd"
-`````````````````````````````
-
-::
-
-  sil-instruction := 'builtin' '"unsafeGuaranteedEnd"' '(' sil-operand')'
-
-  %1 = builtin "unsafeGuaranteedEnd"(%0 : $Builtin.Int1)
-  // $T must be of AnyObject type.
-
-Ends the scope for the ``builtin "unsafeGuaranteed"`` instruction.
-
 Literals
 ~~~~~~~~
 

include/swift/AST/Builtins.def

@@ -723,12 +723,6 @@ BUILTIN_MISC_OPERATION(AssignTakeArray, "assignTakeArray", "", Special)
 /// This builtin indicates to the optimizer that the buffer is not mutable.
 BUILTIN_MISC_OPERATION(COWBufferForReading, "COWBufferForReading", "n", Special)
 
-// unsafeGuaranteed has type <T: AnyObject> T -> (T, Builtin.Int8)
-BUILTIN_MISC_OPERATION(UnsafeGuaranteed, "unsafeGuaranteed", "", Special)
-
-// unsafeGuaranteedEnd has type (Builtin.Int8) -> ()
-BUILTIN_MISC_OPERATION(UnsafeGuaranteedEnd, "unsafeGuaranteedEnd", "", Special)
-
 // getObjCTypeEncoding has type <T> T.Type -> RawPointer
 BUILTIN_MISC_OPERATION(GetObjCTypeEncoding, "getObjCTypeEncoding", "n", Special)
 

include/swift/SILOptimizer/Analysis/ARCAnalysis.h

@@ -392,35 +392,6 @@ class ConsumedArgToEpilogueReleaseMatcher {
 /// Match a call to a trap BB with no ARC relevant side effects.
 bool isARCInertTrapBB(const SILBasicBlock *BB);
 
-/// Get the two result values of the builtin "unsafeGuaranteed" instruction.
-///
-/// Gets the (GuaranteedValue, Token) tuple from a call to "unsafeGuaranteed"
-/// if the tuple elements are identified by a single tuple_extract use.
-/// Otherwise, returns a (nullptr, nullptr) tuple.
-std::pair<SingleValueInstruction *, SingleValueInstruction *>
-getSingleUnsafeGuaranteedValueResult(BuiltinInst *UnsafeGuaranteedInst);
-
-/// Get the single builtin "unsafeGuaranteedEnd" user of a builtin
-/// "unsafeGuaranteed"'s token.
-BuiltinInst *getUnsafeGuaranteedEndUser(SILValue UnsafeGuaranteedToken);
-
-/// Walk forwards from an unsafeGuaranteedEnd builtin instruction looking for a
-/// release on the reference returned by the matching unsafeGuaranteed builtin
-/// ignoring releases on the way.
-/// Return nullptr if no release is found.
-///
-///    %4 = builtin "unsafeGuaranteed"<Foo>(%0 : $Foo) : $(Foo, Builtin.Int8)
-///    %5 = tuple_extract %4 : $(Foo, Builtin.Int8), 0
-///    %6 = tuple_extract %4 : $(Foo, Builtin.Int8), 1
-///    %12 = builtin "unsafeGuaranteedEnd"(%6 : $Builtin.Int8) : $()
-///    strong_release %5 : $Foo // <-- Matching release.
-///
-/// Alternatively, look for the release before the unsafeGuaranteedEnd.
-SILInstruction *findReleaseToMatchUnsafeGuaranteedValue(
-    SILInstruction *UnsafeGuaranteedEndI, SILInstruction *UnsafeGuaranteedI,
-    SILValue UnsafeGuaranteedValue, SILBasicBlock &BB,
-    RCIdentityFunctionInfo &RCFI);
-
 } // end namespace swift
 
 #endif

include/swift/SILOptimizer/PassManager/Passes.def

@@ -410,8 +410,6 @@ PASS(StringOptimization, "string-optimization",
      "Optimization for String operations")
 PASS(SwiftArrayPropertyOpt, "array-property-opt",
      "Loop Specialization for Array Properties")
-PASS(UnsafeGuaranteedPeephole, "unsafe-guaranteed-peephole",
-     "SIL retain/release Peephole Removal for Builtin.unsafeGuaranteed")
 PASS(UsePrespecialized, "use-prespecialized",
      "Use Pre-Specialized Functions")
 PASS(OwnershipDumper, "ownership-dumper",

lib/AST/Builtins.cpp

@@ -2804,12 +2804,6 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::COWBufferForReading:
     return getCOWBufferForReading(Context, Id);
 
-  case BuiltinValueKind::UnsafeGuaranteed:
-    return getUnsafeGuaranteed(Context, Id);
-
-  case BuiltinValueKind::UnsafeGuaranteedEnd:
-    return getUnsafeGuaranteedEnd(Context, Id);
-
   case BuiltinValueKind::ApplyDerivative:
   case BuiltinValueKind::ApplyTranspose:
     llvm_unreachable("Handled above");

lib/IRGen/GenBuiltin.cpp

@@ -135,22 +135,6 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::UnsafeGuaranteedEnd) {
-    // Just consume the incoming argument.
-    assert(args.size() == 1 && "Expecting one incoming argument");
-    (void)args.claimAll();
-    return;
-  }
-
-  if (Builtin.ID == BuiltinValueKind::UnsafeGuaranteed) {
-    // Just forward the incoming argument.
-    assert(args.size() == 1 && "Expecting one incoming argument");
-    out = std::move(args);
-    // This is a token.
-    out.add(llvm::ConstantInt::get(IGF.IGM.Int8Ty, 0));
-    return;
-  }
-
   if (Builtin.ID == BuiltinValueKind::OnFastPath) {
     // The onFastPath builtin has only an effect on SIL level, so we lower it
     // to a no-op.

lib/SIL/IR/OperandOwnership.cpp

@@ -784,7 +784,6 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, USubOver)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, UToSCheckedTrunc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, UToUCheckedTrunc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Unreachable)
-BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, UnsafeGuaranteedEnd)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Xor)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, GenericXor)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, ZExt)
@@ -806,7 +805,6 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, CreateTaskGroup)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, DestroyTaskGroup)
 
 BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, COWBufferForReading)
-BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, UnsafeGuaranteed)
 
 const int PARAMETER_INDEX_CREATE_ASYNC_TASK_FUTURE_FUNCTION = 2;
 const int PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_FUTURE_FUNCTION = 3;

lib/SIL/IR/ValueOwnership.cpp

@@ -386,7 +386,6 @@ struct ValueOwnershipKindBuiltinVisitor
 // This returns a value at +1 that is destroyed strictly /after/ the
 // UnsafeGuaranteedEnd. This provides the guarantee that we want.
 CONSTANT_OWNERSHIP_BUILTIN(Owned, COWBufferForReading)
-CONSTANT_OWNERSHIP_BUILTIN(Owned, UnsafeGuaranteed)
 CONSTANT_OWNERSHIP_BUILTIN(None, AShr)
 CONSTANT_OWNERSHIP_BUILTIN(None, GenericAShr)
 CONSTANT_OWNERSHIP_BUILTIN(None, Add)
@@ -507,7 +506,6 @@ CONSTANT_OWNERSHIP_BUILTIN(None, Unreachable)
 CONSTANT_OWNERSHIP_BUILTIN(None, AtomicRMW)
 
 CONSTANT_OWNERSHIP_BUILTIN(None, CondUnreachable)
-CONSTANT_OWNERSHIP_BUILTIN(None, UnsafeGuaranteedEnd)
 CONSTANT_OWNERSHIP_BUILTIN(None, GetObjCTypeEncoding)
 CONSTANT_OWNERSHIP_BUILTIN(None, CanBeObjCClass)
 CONSTANT_OWNERSHIP_BUILTIN(None, WillThrow)

lib/SIL/Utils/MemAccessUtils.cpp

@@ -2484,8 +2484,6 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     case BuiltinValueKind::Unreachable:
     case BuiltinValueKind::CondUnreachable:
     case BuiltinValueKind::DestroyArray:
-    case BuiltinValueKind::UnsafeGuaranteed:
-    case BuiltinValueKind::UnsafeGuaranteedEnd:
     case BuiltinValueKind::Swift3ImplicitObjCEntrypoint:
     case BuiltinValueKind::PoundAssert:
     case BuiltinValueKind::IntInstrprofIncrement:

lib/SILOptimizer/Analysis/ARCAnalysis.cpp

@@ -1059,127 +1059,3 @@ bool swift::isARCInertTrapBB(const SILBasicBlock *BB) {
   // ARC perspective in an unreachable BB.
   return true;
 }
-
-//===----------------------------------------------------------------------===//
-//             Analysis of builtin "unsafeGuaranteed" instructions
-//===----------------------------------------------------------------------===//
-std::pair<SingleValueInstruction *, SingleValueInstruction *>
-swift::getSingleUnsafeGuaranteedValueResult(BuiltinInst *BI) {
-  assert(BI->getBuiltinKind() &&
-         *BI->getBuiltinKind() == BuiltinValueKind::UnsafeGuaranteed &&
-         "Expecting a unsafeGuaranteed builtin");
-
-  SingleValueInstruction *GuaranteedValue = nullptr;
-  SingleValueInstruction *Token = nullptr;
-
-  auto Failed = std::make_pair(nullptr, nullptr);
-
-  for (auto *Operand : getNonDebugUses(BI)) {
-    auto *Usr = Operand->getUser();
-    if (isa<ReleaseValueInst>(Usr) || isa<RetainValueInst>(Usr))
-      continue;
-
-    auto *TE = dyn_cast<TupleExtractInst>(Usr);
-    if (!TE || TE->getOperand() != BI)
-      return Failed;
-
-    if (TE->getFieldIndex() == 0 && !GuaranteedValue) {
-      GuaranteedValue = TE;
-      continue;
-    }
-    if (TE->getFieldIndex() == 1 && !Token) {
-      Token = TE;
-      continue;
-    }
-    return Failed;
-  }
-
-  if (!GuaranteedValue || !Token)
-    return Failed;
-
-  return std::make_pair(GuaranteedValue, Token);
-}
-
-BuiltinInst *swift::getUnsafeGuaranteedEndUser(SILValue UnsafeGuaranteedToken) {
-  BuiltinInst *UnsafeGuaranteedEndI = nullptr;
-
-  for (auto *Operand : getNonDebugUses(UnsafeGuaranteedToken)) {
-    if (UnsafeGuaranteedEndI) {
-      LLVM_DEBUG(llvm::dbgs() << "  multiple unsafeGuaranteedEnd users\n");
-      UnsafeGuaranteedEndI = nullptr;
-      break;
-    }
-    auto *BI = dyn_cast<BuiltinInst>(Operand->getUser());
-    if (!BI || !BI->getBuiltinKind() ||
-        *BI->getBuiltinKind() != BuiltinValueKind::UnsafeGuaranteedEnd) {
-      LLVM_DEBUG(llvm::dbgs() << "  wrong unsafeGuaranteed token user "
-                 << *Operand->getUser());
-      break;
-    }
-
-    UnsafeGuaranteedEndI = BI;
-  }
-  return UnsafeGuaranteedEndI;
-}
-
-static bool hasUnsafeGuaranteedOperand(SILValue UnsafeGuaranteedValue,
-                                       SILValue UnsafeGuaranteedValueOperand,
-                                       RCIdentityFunctionInfo &RCII,
-                                       SILInstruction &Release) {
-  assert(isa<StrongReleaseInst>(Release) ||
-         isa<ReleaseValueInst>(Release) && "Expecting a release");
-
-  auto RCRoot = RCII.getRCIdentityRoot(Release.getOperand(0));
-
-  return RCRoot == UnsafeGuaranteedValue ||
-         RCRoot == UnsafeGuaranteedValueOperand;
-}
-
-SILInstruction *swift::findReleaseToMatchUnsafeGuaranteedValue(
-    SILInstruction *UnsafeGuaranteedEndI, SILInstruction *UnsafeGuaranteedI,
-    SILValue UnsafeGuaranteedValue, SILBasicBlock &BB,
-    RCIdentityFunctionInfo &RCFI) {
-
-  auto UnsafeGuaranteedRoot = RCFI.getRCIdentityRoot(UnsafeGuaranteedValue);
-  auto UnsafeGuaranteedOpdRoot =
-      RCFI.getRCIdentityRoot(UnsafeGuaranteedI->getOperand(0));
-
-  // Try finding it after the "unsafeGuaranteedEnd".
-  for (auto ForwardIt = std::next(UnsafeGuaranteedEndI->getIterator()),
-            End = BB.end();
-       ForwardIt != End; ++ForwardIt) {
-    SILInstruction &CurInst = *ForwardIt;
-
-    // Is this a release?
-    if (isa<ReleaseValueInst>(CurInst) || isa<StrongReleaseInst>(CurInst)) {
-      if (hasUnsafeGuaranteedOperand(UnsafeGuaranteedRoot,
-                                     UnsafeGuaranteedOpdRoot, RCFI, CurInst))
-        return &CurInst;
-      continue;
-    }
-
-    if (CurInst.mayHaveSideEffects() && !DebugValueInst::hasAddrVal(&CurInst))
-      break;
-  }
-
-  // Otherwise, Look before the "unsafeGuaranteedEnd".
-  for (auto ReverseIt = ++UnsafeGuaranteedEndI->getIterator().getReverse(),
-            End = BB.rend();
-       ReverseIt != End; ++ReverseIt) {
-    SILInstruction &CurInst = *ReverseIt;
-
-    // Is this a release?
-    if (isa<ReleaseValueInst>(CurInst) || isa<StrongReleaseInst>(CurInst)) {
-      if (hasUnsafeGuaranteedOperand(UnsafeGuaranteedRoot,
-                                     UnsafeGuaranteedOpdRoot, RCFI, CurInst))
-        return &CurInst;
-      continue;
-    }
-
-    if (CurInst.mayHaveSideEffects() && !DebugValueInst::hasAddrVal(&CurInst))
-      break;
-  }
-
-  return nullptr;
-}
-