Remove now unused utility functions for escape checking.

Those functions were replaced by EscapeAnalysis.

Author: eeckstein

include/swift/SIL/SILValueProjection.h

@@ -477,18 +477,6 @@ class LSLocation : public SILValueProjection {
   /// projection.
   void getFirstLevelLSLocations(LSLocationList &Locs, SILModule *Mod);
 
-  /// Returns true if the LSLocation is local to this function, i.e.
-  /// does not escape.
-  ///
-  /// TODO: we should look at the projection path as well. i.e. one field
-  /// might escape but the object itself does not.
-  ///
-  bool isNonEscapingLocalLSLocation() {
-    assert(isValid() && "Invalid memory location");
-    // TODO: this does not have to be limited to allocstack.
-    return isa<AllocStackInst>(Base) && isNonEscapingLocalObject(Base);
-  }
-
   /// Check whether the 2 LSLocations may alias each other or not.
   bool isMayAliasLSLocation(const LSLocation &RHS, AliasAnalysis *AA);
 

include/swift/SILOptimizer/Analysis/ValueTracking.h

@@ -42,10 +42,6 @@ bool isNotAliasingArgument(SILValue V, InoutAliasingAssumption isInoutAliasing =
   bool pointsToLocalObject(SILValue V, InoutAliasingAssumption isInoutAliasing =
                                          InoutAliasingAssumption::Aliasing);
 
-/// Return true if the pointer is to a function-local object that never escapes
-/// from the function.
-bool isNonEscapingLocalObject(SILValue V);
-
 enum class IsZeroKind {
   Zero,
   NotZero,

lib/SILOptimizer/Analysis/ValueTracking.cpp

@@ -35,275 +35,6 @@ SILValue swift::getUnderlyingObject(SILValue V) {
   }
 }
 
-/// Returns true if the ValueBase inside V is an apply whose callee is a no read
-/// builtin.
-static bool isNoReadBuiltinInst(SILValue V) {
-  auto *BI = dyn_cast<BuiltinInst>(V);
-  return BI && !BI->mayReadOrWriteMemory();
-}
-
-/// Is Inst an instruction which escapes if and only if one of its results
-/// escape?
-static bool isTransitiveEscapeInst(SILInstruction *Inst) {
-  switch (Inst->getKind()) {
-  case ValueKind::AllocBoxInst:
-  case ValueKind::AllocExistentialBoxInst:
-  case ValueKind::AllocRefInst:
-  case ValueKind::AllocRefDynamicInst:
-  case ValueKind::AllocStackInst:
-  case ValueKind::AllocValueBufferInst:
-  case ValueKind::BuiltinInst:
-  case ValueKind::ApplyInst:
-  case ValueKind::TryApplyInst:
-  case ValueKind::WitnessMethodInst:
-  case ValueKind::CopyAddrInst:
-  case ValueKind::RetainValueInst:
-  case ValueKind::DeallocBoxInst:
-  case ValueKind::DeallocExistentialBoxInst:
-  case ValueKind::DeallocRefInst:
-  case ValueKind::DeallocPartialRefInst:
-  case ValueKind::DeallocStackInst:
-  case ValueKind::DeallocValueBufferInst:
-  case ValueKind::DebugValueAddrInst:
-  case ValueKind::DebugValueInst:
-  case ValueKind::DestroyAddrInst:
-  case ValueKind::ReleaseValueInst:
-  case ValueKind::AutoreleaseValueInst:
-  case ValueKind::FloatLiteralInst:
-  case ValueKind::FunctionRefInst:
-  case ValueKind::IntegerLiteralInst:
-  case ValueKind::LoadInst:
-  case ValueKind::LoadUnownedInst:
-  case ValueKind::LoadWeakInst:
-  case ValueKind::MetatypeInst:
-  case ValueKind::ObjCProtocolInst:
-  case ValueKind::GlobalAddrInst:
-  case ValueKind::StoreInst:
-  case ValueKind::StoreUnownedInst:
-  case ValueKind::StoreWeakInst:
-  case ValueKind::StringLiteralInst:
-  case ValueKind::CopyBlockInst:
-  case ValueKind::StrongReleaseInst:
-  case ValueKind::StrongPinInst: // Pin handle is independently managed
-  case ValueKind::StrongRetainInst:
-  case ValueKind::StrongRetainUnownedInst:
-  case ValueKind::StrongUnpinInst:
-  case ValueKind::UnownedReleaseInst:
-  case ValueKind::UnownedRetainInst:
-  case ValueKind::IsUniqueInst:
-  case ValueKind::IsUniqueOrPinnedInst:
-  case ValueKind::InjectEnumAddrInst:
-  case ValueKind::DeinitExistentialAddrInst:
-  case ValueKind::UnreachableInst:
-  case ValueKind::IsNonnullInst:
-  case ValueKind::CondFailInst:
-  case ValueKind::DynamicMethodBranchInst:
-  case ValueKind::ReturnInst:
-  case ValueKind::ThrowInst:
-  case ValueKind::FixLifetimeInst:
-    return false;
-
-  case ValueKind::AddressToPointerInst:
-  case ValueKind::ValueMetatypeInst:
-  case ValueKind::BranchInst:
-  case ValueKind::CheckedCastBranchInst:
-  case ValueKind::CheckedCastAddrBranchInst:
-  case ValueKind::ClassMethodInst:
-  case ValueKind::CondBranchInst:
-  case ValueKind::ConvertFunctionInst:
-  case ValueKind::DynamicMethodInst:
-  case ValueKind::EnumInst:
-  case ValueKind::IndexAddrInst:
-  case ValueKind::IndexRawPointerInst:
-  case ValueKind::InitBlockStorageHeaderInst:
-  case ValueKind::InitEnumDataAddrInst:
-  case ValueKind::InitExistentialAddrInst:
-  case ValueKind::InitExistentialMetatypeInst:
-  case ValueKind::InitExistentialRefInst:
-  case ValueKind::ObjCExistentialMetatypeToObjectInst:
-  case ValueKind::ObjCMetatypeToObjectInst:
-  case ValueKind::ObjCToThickMetatypeInst:
-  case ValueKind::UncheckedRefCastInst:
-  case ValueKind::UncheckedRefCastAddrInst:
-  case ValueKind::UncheckedAddrCastInst:
-  case ValueKind::UncheckedTrivialBitCastInst:
-  case ValueKind::UncheckedBitwiseCastInst:
-  case ValueKind::MarkDependenceInst:
-  case ValueKind::OpenExistentialAddrInst:
-  case ValueKind::OpenExistentialMetatypeInst:
-  case ValueKind::OpenExistentialRefInst:
-  case ValueKind::OpenExistentialBoxInst:
-  case ValueKind::PartialApplyInst:
-  case ValueKind::ProjectBoxInst:
-  case ValueKind::ProjectValueBufferInst:
-  case ValueKind::PointerToAddressInst:
-  case ValueKind::PointerToThinFunctionInst:
-  case ValueKind::ProjectBlockStorageInst:
-  case ValueKind::ExistentialMetatypeInst:
-  case ValueKind::RawPointerToRefInst:
-  case ValueKind::RefElementAddrInst:
-  case ValueKind::RefToRawPointerInst:
-  case ValueKind::RefToUnmanagedInst:
-  case ValueKind::RefToUnownedInst:
-  case ValueKind::SelectEnumInst:
-  case ValueKind::SelectEnumAddrInst:
-  case ValueKind::SelectValueInst:
-  case ValueKind::StructElementAddrInst:
-  case ValueKind::StructExtractInst:
-  case ValueKind::StructInst:
-  case ValueKind::SuperMethodInst:
-  case ValueKind::SwitchEnumAddrInst:
-  case ValueKind::SwitchEnumInst:
-  case ValueKind::SwitchValueInst:
-  case ValueKind::UncheckedEnumDataInst:
-  case ValueKind::UncheckedTakeEnumDataAddrInst:
-  case ValueKind::ThickToObjCMetatypeInst:
-  case ValueKind::ThinFunctionToPointerInst:
-  case ValueKind::ThinToThickFunctionInst:
-  case ValueKind::TupleElementAddrInst:
-  case ValueKind::TupleExtractInst:
-  case ValueKind::TupleInst:
-  case ValueKind::UnconditionalCheckedCastInst:
-  case ValueKind::UnconditionalCheckedCastAddrInst:
-  case ValueKind::UnmanagedToRefInst:
-  case ValueKind::UnownedToRefInst:
-  case ValueKind::UpcastInst:
-  case ValueKind::RefToBridgeObjectInst:
-  case ValueKind::BridgeObjectToRefInst:
-  case ValueKind::BridgeObjectToWordInst:
-    return true;
-
-  case ValueKind::AssignInst:
-  case ValueKind::MarkFunctionEscapeInst:
-  case ValueKind::MarkUninitializedInst:
-    llvm_unreachable("Invalid in canonical SIL.");
-
-  case ValueKind::SILArgument:
-  case ValueKind::SILUndef:
-    llvm_unreachable("These do not use other values.");
-  }
-}
-
-/// Maximum amount of ValueCapture queries.
-static unsigned const ValueCaptureSearchThreshold = 32;
-
-namespace {
-
-/// Are there any uses that should be ignored as capture uses.
-///
-/// TODO: Expand this if we ever do the store of pointer analysis mentioned in
-/// Basic AA.
-enum CaptureException : unsigned {
-  None=0,
-  ReturnsCannotCapture=1,
-};
-
-} // end anonymous namespace
-
-/// Returns true if V is a value that is used in a manner such that we know its
-/// captured or we don't understand whether or not it was captured. In such a
-/// case to be conservative, we must assume it is captured.
-/// FIXME: Maybe put this on SILValue?
-static bool valueMayBeCaptured(SILValue V, CaptureException Exception) {
-  llvm::SmallVector<Operand *, ValueCaptureSearchThreshold> Worklist;
-  llvm::SmallPtrSet<Operand *, ValueCaptureSearchThreshold> Visited;
-  unsigned Count = 0;
-
-  DEBUG(llvm::dbgs() << "        Checking for capture.\n");
-  
-
-  // All uses of V to the worklist.
-  for (auto *UI : V.getUses()) {
-    // If we have more uses than the threshold, be conservative and bail so we
-    // don't use too much compile time.
-    if (Count++ >= ValueCaptureSearchThreshold)
-      return true;
-    Visited.insert(UI);
-    Worklist.push_back(UI);
-  }
-
-  // Until the worklist is empty...
-  while (!Worklist.empty()) {
-    // Pop off an operand and grab the operand's user...
-    Operand *Op = Worklist.pop_back_val();
-    SILInstruction *Inst = Op->getUser();
-
-    DEBUG(llvm::dbgs() << "            Visiting: " << *Inst);
-
-    // If Inst is an instruction with the transitive escape property, V escapes
-    // if and only if the results of Inst escape as well.
-    if (isTransitiveEscapeInst(Inst)) {
-      DEBUG(llvm::dbgs() << "                Found transitive escape "
-            "instruction!\n");
-      for (auto *UI : Inst->getUses()) {
-        // If we have more uses than the threshold, be conservative and bail
-        // so we don't use too much compile time.
-        if (Count++ >= ValueCaptureSearchThreshold)
-          return true;
-
-        if (Visited.insert(UI).second) {
-          Worklist.push_back(UI);
-        }
-      }
-      continue;
-    }
-
-    // An apply of a builtin that does not read memory cannot capture a value.
-    //
-    // TODO: Use analysis of the other function perhaps to see if it captures
-    // memory in some manner?
-    // TODO: Add in knowledge about how parameters work on swift to make this
-    // more aggressive.
-    if (isNoReadBuiltinInst(Inst))
-      continue;
-
-    // Loading from a pointer does not cause it to be captured.
-    if (isa<LoadInst>(Inst))
-      continue;
-
-    // If we have a store and are storing into the pointer, this is not a
-    // capture. Otherwise it is safe.
-    if (auto *SI = dyn_cast<StoreInst>(Inst)) {
-      if (SI->getDest() == Op->get()) {
-        continue;
-      } else {
-        return true;
-      }
-    }
-
-    // Deallocation instructions don't capture.
-    if (isa<DeallocationInst>(Inst))
-      continue;
-
-    // Debug instructions don't capture.
-    if (isa<DebugValueInst>(Inst) || isa<DebugValueAddrInst>(Inst))
-      continue;
-
-    // RefCountOperations don't capture.
-    //
-    // The release case is true since Swift does not allow destructors to
-    // resurrect objects. This is enforced via a runtime failure.
-    if (isa<RefCountingInst>(Inst))
-      continue;
-
-    // If we have a return instruction and we are assuming that returns don't
-    // capture, we are safe.
-    if (Exception == CaptureException::ReturnsCannotCapture &&
-        isa<ReturnInst>(Inst))
-      continue;
-
-    // We could not prove that Inst does not capture V. Be conservative and
-    // return true.
-    DEBUG(llvm::dbgs() << "        Could not prove that inst does not capture "
-          "V!\n");
-    return true;
-  }
-
-  // We successfully proved that V is not captured. Return false.
-  DEBUG(llvm::dbgs() << "        V was not captured!\n");
-  return false;
-}
-
 bool swift::isNotAliasingArgument(SILValue V,
                                   InoutAliasingAssumption isInoutAliasing) {
   auto *Arg = dyn_cast<SILArgument>(V);
@@ -321,32 +52,6 @@ bool swift::pointsToLocalObject(SILValue V,
         isNotAliasingArgument(V, isInoutAliasing);
 }
 
-/// Return true if the pointer is to a function-local object that never escapes
-/// from the function.
-bool swift::isNonEscapingLocalObject(SILValue V) {
-  // If this is a local allocation, or the result of a no read apply inst (which
-  // cannot affect memory in the caller), check to see if the allocation
-  // escapes.
-  if (isa<AllocationInst>(*V) || isNoReadBuiltinInst(V))
-    return !valueMayBeCaptured(V, CaptureException::ReturnsCannotCapture);
-
-  // If this is a no alias argument then it has not escaped before entering the
-  // function. Check if it escapes inside the function.
-  if (isNotAliasingArgument(V))
-      return !valueMayBeCaptured(V, CaptureException::ReturnsCannotCapture);
-
-  // If this is an enum value. If it or its operand does not escape, it is
-  // local.
-  if (auto *EI = dyn_cast<EnumInst>(V))
-    return !EI->hasOperand() ||
-           !valueMayBeCaptured(EI->getOperand(),
-                               CaptureException::ReturnsCannotCapture);
-
-  // Otherwise we could not prove that V is a non escaping local object. Be
-  // conservative and return false.
-  return false;
-}
-
 /// Check if the value \p Value is known to be zero, non-zero or unknown.
 IsZeroKind swift::isZeroValue(SILValue Value) {
   // Inspect integer literals.