Add AddressOwnership OSSA utility

This replaces the recent BorrowedAddress utility (the address may not
be borrowed!)

APIs:

AddressOwnership::hasLocalOwnershipLifetime() - convenience on top of
AccessBase::hasLocalOwnershipLifetime().

AddressOwnership::getOwnershipReferenceRoot() - convenience on top of
AccessBase::getOwnershipReferenceRoot().

AddressOwnership::findTransitiveUses() - wrapper API over the internal
helper findTransitiveUsesForAddress()

AddressOwnership::areUsesWithinLifetime() - wrapper adds a quick check
on top of BorrowedValue::areUsesWithinLifetime()

Author: atrick

include/swift/SIL/OwnershipUtils.h

@@ -662,6 +662,13 @@ bool getAllBorrowIntroducingValues(SILValue value,
 /// introducer, then we return a .some(BorrowScopeIntroducingValue).
 BorrowedValue getSingleBorrowIntroducingValue(SILValue inputValue);
 
+/// The algorithm that is used to determine what the verifier will consider to
+/// be transitive uses of the given address. Used to implement \see
+/// findTransitiveUses.
+bool findTransitiveUsesForAddress(
+    SILValue address, SmallVectorImpl<Operand *> &foundUses,
+    std::function<void(Operand *)> *onError = nullptr);
+
 class InteriorPointerOperandKind {
 public:
   enum Kind : uint8_t {
@@ -805,7 +812,7 @@ struct InteriorPointerOperand {
   }
 
   /// Return the base BorrowedValue of the incoming value's operand.
-  BorrowedValue getSingleBaseValue() const {
+  BorrowedValue getSingleBorrowedValue() const {
     return getSingleBorrowIntroducingValue(operand->get());
   }
 
@@ -840,14 +847,6 @@ struct InteriorPointerOperand {
                                         onError);
   }
 
-  /// The algorithm that is used to determine what the verifier will consider to
-  /// be transitive uses of the given address. Used to implement \see
-  /// findTransitiveUses.
-  static bool
-  findTransitiveUsesForAddress(SILValue address,
-                               SmallVectorImpl<Operand *> &foundUses,
-                               std::function<void(Operand *)> *onError = nullptr);
-
   Operand *operator->() { return operand; }
   const Operand *operator->() const { return operand; }
   Operand *operator*() { return operand; }
@@ -860,23 +859,70 @@ struct InteriorPointerOperand {
       : operand(op), kind(kind) {}
 };
 
-/// Utility to check if an address may originate from a borrowed value. If so,
+/// Utility to check if an address may originate from an OSSA value. If so,
 /// then uses of the address cannot be replaced without ensuring that they are
-/// also within the same scope.
+/// also within the same owned lifetime or borrow scope.
 ///
-/// If mayBeBorrowed is false, then there is no enclosing borrow scope and
-/// interiorPointerOp is irrelevant.
+/// If hasOwnership() is false, then there is no enclosing lifetime or borrow
+/// scope and interiorPointerOp is irrelevant.
 ///
-/// If mayBeBorrowed is true, then interiorPointerOp refers to the operand that
+/// If hasOwnership() is true, then interiorPointerOp refers to the operand that
 /// converts a non-address value into the address from which the contructor's
 /// address is derived. If the best-effort to find an InteriorPointerOperand
 /// fails, then interiorPointerOp remains invalid, and clients must be
 /// conservative.
-struct BorrowedAddress {
-  bool mayBeBorrowed = true;
-  InteriorPointerOperand interiorPointerOp;
+///
+/// TODO: Handle implicit borrow scopes once they are legal in SIL. The operand
+/// of the base will be owned but mayBeBorrowed will remain true.
+struct AddressOwnership {
+  AccessBase base;
+
+  AddressOwnership() = default;
+
+  AddressOwnership(SILValue address) : base(AccessBase::compute(address)) {
+    assert(address->getType().isAddress());
+  }
 
-  BorrowedAddress(SILValue address);
+  AddressOwnership(AccessBase base) : base(base) {}
+
+  operator bool() const { return bool(base); }
+
+  bool operator==(const AddressOwnership &other) const {
+    return base.hasIdenticalAccessInfo(other.base);
+  }
+
+  bool operator!=(const AddressOwnership &other) const {
+    return !(*this == other);
+  }
+
+  /// Return true if this address may be derived from a value with a local OSSA
+  /// lifetime or borrow scope.
+  bool hasLocalOwnershipLifetime() const {
+    return base.hasLocalOwnershipLifetime();
+  }
+
+  /// Return the OSSA value from which this address is derived. This may be
+  /// invalid even if hasOSSALifetime() is true in cases where the
+  /// InteriorPointerOperand is unrecognized.
+  SILValue getOwnershipReferenceRoot() const {
+    if (base.isReference())
+      return base.getOwnershipReferenceRoot();
+
+    return SILValue();
+  }
+
+  /// Transitively compute uses of this base address.
+  bool findTransitiveUses(SmallVectorImpl<Operand *> &foundUses) {
+    return findTransitiveUsesForAddress(base.getBaseAddress(), foundUses);
+  }
+
+  /// Return true of all \p uses occur before the end of the address' lifetime
+  /// or borrow scope.
+  ///
+  /// Precondition: all \p uses are dominated by the beginning of the address'
+  /// lifetime or borrow scope.
+  bool areUsesWithinLifetime(ArrayRef<Operand *> uses,
+                             DeadEndBlocks &deadEndBlocks) const;
 };
 
 class OwnedValueIntroducerKind {

lib/SIL/Utils/OwnershipUtils.cpp

@@ -704,11 +704,7 @@ bool BorrowedValue::visitInteriorPointerOperandHelper(
   return true;
 }
 
-//===----------------------------------------------------------------------===//
-//                           InteriorPointerOperand
-//===----------------------------------------------------------------------===//
-
-bool InteriorPointerOperand::findTransitiveUsesForAddress(
+bool swift::findTransitiveUsesForAddress(
     SILValue projectedAddress, SmallVectorImpl<Operand *> &foundUses,
     std::function<void(Operand *)> *onError) {
   SmallVector<Operand *, 8> worklist(projectedAddress->getUses());
@@ -814,44 +810,26 @@ bool InteriorPointerOperand::findTransitiveUsesForAddress(
   return foundError;
 }
 
-// Determine whether \p address may be in a borrow scope and if so record the
-// InteriorPointerOperand that produces the address from a guaranteed value.
-BorrowedAddress::BorrowedAddress(SILValue address) {
-  assert(address->getType().isAddress());
-
-  auto storageWithBase = AccessStorageWithBase::compute(address);
-  switch (storageWithBase.storage.getKind()) {
-  case AccessStorage::Argument:
-  case AccessStorage::Stack:
-  case AccessStorage::Global:
-  // Unidentified storage is from an "escaped pointer", so it need not be
-  // restricted to a borrow scope.
-  case AccessStorage::Unidentified:
-    this->mayBeBorrowed = false;
-    return;
-  case AccessStorage::Box:
-  case AccessStorage::Yield:
-  case AccessStorage::Class:
-  case AccessStorage::Tail:
-    // The base object might be within a borrow scope.
-    break;
-  case AccessStorage::Nested:
-    llvm_unreachable("unexpected storage");
-  };
-  auto base = storageWithBase.base;
-  if (!base)
-    return; // bail on unexpected patterns
+//===----------------------------------------------------------------------===//
+//                              AddressOwnership
+//===----------------------------------------------------------------------===//
 
-  auto intPtrOp = InteriorPointerOperand::inferFromResult(base);
-  if (!intPtrOp)
-    return;
+bool AddressOwnership::areUsesWithinLifetime(
+    ArrayRef<Operand *> uses, DeadEndBlocks &deadEndBlocks) const {
+  if (!base.hasLocalOwnershipLifetime())
+    return true;
 
-  SILValue nonAddressValue = intPtrOp.operand->get();
-  if (nonAddressValue->getOwnershipKind() != OwnershipKind::Guaranteed) {
-    this->mayBeBorrowed = false;
-    return;
-  }
-  this->interiorPointerOp = intPtrOp;
+  SILValue root = base.getOwnershipReferenceRoot();
+  BorrowedValue borrow(root);
+  if (borrow)
+    return borrow.areUsesWithinLocalScope(uses, deadEndBlocks);
+
+  // --- A reference no borrow scope. Currently happens for project_box.
+
+  // Compute the reference value's liveness.
+  PrunedLiveness liveness;
+  liveness.computeSSALiveness(root);
+  return liveness.areUsesWithinBoundary(uses, deadEndBlocks);
 }
 
 //===----------------------------------------------------------------------===//
@@ -961,6 +939,7 @@ bool swift::getAllBorrowIntroducingValues(SILValue inputValue,
   return true;
 }
 
+// FIXME: replace this logic with AccessBase::findOwnershipReferenceRoot.
 BorrowedValue swift::getSingleBorrowIntroducingValue(SILValue inputValue) {
   if (inputValue.getOwnershipKind() != OwnershipKind::Guaranteed)
     return {};

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -1137,24 +1137,27 @@ OwnershipRAUWHelper::OwnershipRAUWHelper(OwnershipFixupContext &inputCtx,
   //
   // NOTE: We also need to handle this here since a pointer_to_address is not a
   // valid base value for an access path since it doesn't refer to any storage.
-  BorrowedAddress borrowedAddress(newValue);
-  if (!borrowedAddress.mayBeBorrowed)
+  AddressOwnership addressOwnership(newValue);
+  if (!addressOwnership.hasLocalOwnershipLifetime())
     return;
 
-  if (!borrowedAddress.interiorPointerOp) {
+  auto intPtrOp =
+    InteriorPointerOperand::inferFromResult(
+      addressOwnership.base.getBaseAddress());
+  if (!intPtrOp) {
     invalidate();
     return;
   }
 
-  ctx->extraAddressFixupInfo.intPtrOp = borrowedAddress.interiorPointerOp;
-  auto borrowedValue = borrowedAddress.interiorPointerOp.getSingleBaseValue();
+  ctx->extraAddressFixupInfo.intPtrOp = intPtrOp;
+  auto borrowedValue = intPtrOp.getSingleBorrowedValue();
   if (!borrowedValue) {
     invalidate();
     return;
   }
 
   auto *intPtrInst =
-    cast<SingleValueInstruction>(borrowedAddress.interiorPointerOp.getUser());
+    cast<SingleValueInstruction>(intPtrOp.getUser());
   auto checkBase = [&](SILValue srcAddr) {
     return (srcAddr == intPtrInst) ? SILValue(intPtrInst) : SILValue();
   };
@@ -1167,8 +1170,7 @@ OwnershipRAUWHelper::OwnershipRAUWHelper(OwnershipFixupContext &inputCtx,
 
   // For now, just gather up uses
   auto &oldValueUses = ctx->extraAddressFixupInfo.allAddressUsesFromOldValue;
-  if (InteriorPointerOperand::findTransitiveUsesForAddress(oldValue,
-                                                           oldValueUses)) {
+  if (findTransitiveUsesForAddress(oldValue, oldValueUses)) {
     invalidate();
     return;
   }
@@ -1177,9 +1179,7 @@ OwnershipRAUWHelper::OwnershipRAUWHelper(OwnershipFixupContext &inputCtx,
   // need to perform the copy or not when we actually RAUW. So perform the is
   // within region check. If we succeed, clear our extra state so we perform a
   // normal RAUW.
-  SmallVector<Operand *, 8> scratchSpace;
-  if (borrowedValue.areUsesWithinScope(oldValueUses, scratchSpace,
-                                       ctx->deBlocks)) {
+  if (borrowedValue.areUsesWithinLocalScope(oldValueUses, ctx->deBlocks)) {
     // We do not need to copy the base value! Clear the extra info we have.
     ctx->extraAddressFixupInfo.clear();
   }