Merge pull request swiftlang#39576 from atrick/access-base

Author: swift-ci

include/swift/SIL/MemAccessUtils.h

@@ -204,6 +204,11 @@ SILValue findReferenceRoot(SILValue ref);
 /// Find the first owned root of the reference.
 SILValue findOwnershipReferenceRoot(SILValue ref);
 
+/// Find the aggregate containing the first owned root of the
+/// reference. Identical to findOwnershipReferenceRoot, but looks through
+/// struct_extract, tuple_extract, etc.
+SILValue findOwnershipReferenceAggregate(SILValue ref);
+
 /// Return true if \p address points to a let-variable.
 ///
 /// let-variables are only written during let-variable initialization, which is
@@ -546,6 +551,17 @@ class AccessRepresentation {
 /// require traversing phis.
 class AccessBase : public AccessRepresentation {
 public:
+  /// Return an AccessBase for the formally accessed variable pointed to by \p
+  /// sourceAddress.
+  ///
+  /// \p sourceAddress may be an address type or Builtin.RawPointer.
+  ///
+  /// If \p sourceAddress is within a formal access scope, which does not have
+  /// "Unsafe" enforcement, then this always returns the valid base.
+  ///
+  /// If \p sourceAddress is not within a formal access scope, or within an
+  /// "Unsafe" scope, then this finds the formal base if possible,
+  /// otherwise returning an invalid base.
   static AccessBase compute(SILValue sourceAddress);
 
   // Do not add any members to this class. AccessBase can be copied as
@@ -576,6 +592,20 @@ class AccessBase : public AccessRepresentation {
   /// Precondition: isReference() is true.
   SILValue getReference() const;
 
+  /// Return the OSSA root of the reference being accessed.
+  ///
+  /// Precondition: isReference() is true.
+  SILValue getOwnershipReferenceRoot() const {
+    return findOwnershipReferenceRoot(getReference());
+  }
+
+  /// Return the storage root of the reference being accessed.
+  ///
+  /// Precondition: isReference() is true.
+  SILValue getStorageReferenceRoot() const {
+    return findReferenceRoot(getReference());
+  }
+
   /// Return the global variable being accessed.
   ///
   /// Precondition: getKind() == Global
@@ -585,6 +615,16 @@ class AccessBase : public AccessRepresentation {
   /// determined. Otherwise returns null.
   const ValueDecl *getDecl() const;
 
+  /// Return true if this base address may be derived from a reference that is
+  /// only valid within a locally scoped OSSA lifetime. This is not true for
+  /// scoped storage such as alloc_stack and @in argument. It can be
+  /// independently assumed that addresses are only used within the scope of the
+  /// storage object.
+  ///
+  /// Useful to determine whether addresses with the same AccessStorage are in
+  /// fact substitutable without fixing OSSA lifetime.
+  bool hasLocalOwnershipLifetime() const;
+
   void print(raw_ostream &os) const;
   void dump() const;
 };
@@ -720,10 +760,6 @@ class AccessStorage : public AccessRepresentation {
     return hasIdenticalAccessInfo(other);
   }
 
-  /// Return true if this storage is valid for all uses in a function without
-  /// checking its lifetime.
-  bool isGuaranteedForFunction() const;
-
   /// Returns the ValueDecl for the underlying storage, if it can be
   /// determined. Otherwise returns null.
   const ValueDecl *getDecl() const;

include/swift/SIL/SILInstruction.h

@@ -4937,6 +4937,8 @@ class ConversionInst : public SingleValueInstruction {
 
 /// A conversion inst that produces a static OwnershipKind set upon the
 /// instruction's construction.
+///
+/// The first operand is the ownership equivalent source.
 class OwnershipForwardingConversionInst : public ConversionInst,
                                           public OwnershipForwardingMixin {
 protected:
@@ -7877,6 +7879,8 @@ class TermInst : public NonValueInstruction {
   TermKind getTermKind() const { return TermKind(getKind()); }
 
   /// Returns true if this is a transformation terminator.
+  ///
+  /// The first operand is the transformed source.
   bool isTransformationTerminator() const {
     switch (getTermKind()) {
     case TermKind::UnwindInst:
@@ -9396,6 +9400,7 @@ SILFunction *ApplyInstBase<Impl, Base, false>::getCalleeFunction() const {
   }
 }
 
+/// The first operand is the ownership equivalent source.
 class OwnershipForwardingMultipleValueInstruction
     : public MultipleValueInstruction,
       public OwnershipForwardingMixin {

lib/SIL/Utils/MemAccessUtils.cpp

@@ -258,47 +258,74 @@ class FindAccessBaseVisitor
   using SuperTy = FindAccessVisitorImpl<FindAccessBaseVisitor>;
 
 protected:
-  Optional<SILValue> base;
+  // If the optional baseVal is set, then a result was found. If the SILValue
+  // within the optional is invalid, then there are multiple inconsistent base
+  // addresses (this may currently happen with RawPointer phis).
+  Optional<SILValue> baseVal;
+  // If the kind optional is set, then 'baseVal' is a valid
+  // AccessBase. 'baseVal' may be a valid SILValue while kind optional has no
+  // value if an invalid address producer was detected, via a call to
+  // visitNonAccess.
+  Optional<AccessBase::Kind> kindVal;
 
 public:
   FindAccessBaseVisitor(NestedAccessType nestedAccessTy,
                         StorageCastTy storageCastTy)
       : FindAccessVisitorImpl(nestedAccessTy, storageCastTy) {}
 
   // Returns the accessed address or an invalid SILValue.
-  SILValue findBase(SILValue sourceAddr) && {
+  SILValue findPossibleBaseAddress(SILValue sourceAddr) && {
     reenterUseDef(sourceAddr);
-    return base.getValueOr(SILValue());
+    return baseVal.getValueOr(SILValue());
+  }
+
+  AccessBase findBase(SILValue sourceAddr) && {
+    reenterUseDef(sourceAddr);
+    if (!baseVal || !kindVal)
+      return AccessBase();
+
+    return AccessBase(baseVal.getValue(), kindVal.getValue());
   }
 
   void setResult(SILValue foundBase) {
-    if (!base)
-      base = foundBase;
-    else if (base.getValue() != foundBase)
-      base = SILValue();
+    if (!baseVal)
+      baseVal = foundBase;
+    else if (baseVal.getValue() != foundBase)
+      baseVal = SILValue();
   }
 
   // MARK: AccessPhiVisitor::UseDefVisitor implementation.
 
-  bool isResultValid() const { return base && bool(base.getValue()); }
+  // Keep going as long as baseVal is valid regardless of kindVal.
+  bool isResultValid() const { return baseVal && bool(baseVal.getValue()); }
 
-  void invalidateResult() { base = SILValue(); }
+  void invalidateResult() {
+    baseVal = SILValue();
+    kindVal = None;
+  }
 
-  Optional<SILValue> saveResult() const { return base; }
+  Optional<SILValue> saveResult() const { return baseVal; }
 
-  void restoreResult(Optional<SILValue> result) { base = result; }
+  void restoreResult(Optional<SILValue> result) { baseVal = result; }
 
   void addUnknownOffset() { return; }
 
   // MARK: visitor implementation.
 
   SILValue visitBase(SILValue base, AccessStorage::Kind kind) {
     setResult(base);
+    if (!baseVal.getValue()) {
+      kindVal = None;
+    } else {
+      assert(!kindVal || kindVal.getValue() == kind);
+      kindVal = kind;
+    }
     return SILValue();
   }
 
   SILValue visitNonAccess(SILValue value) {
     setResult(value);
+    kindVal = None;
     return SILValue();
   }
 
@@ -322,7 +349,7 @@ SILValue swift::getTypedAccessAddress(SILValue address) {
   SILValue accessAddress =
       FindAccessBaseVisitor(NestedAccessType::StopAtAccessBegin,
                             StopAtStorageCast)
-          .findBase(address);
+          .findPossibleBaseAddress(address);
   assert(accessAddress->getType().isAddress());
   return accessAddress;
 }
@@ -334,14 +361,14 @@ SILValue swift::getAccessScope(SILValue address) {
   assert(address->getType().isAddress());
   return FindAccessBaseVisitor(NestedAccessType::StopAtAccessBegin,
                                IgnoreStorageCast)
-      .findBase(address);
+      .findPossibleBaseAddress(address);
 }
 
 // This is allowed to be called on a non-address pointer type.
 SILValue swift::getAccessBase(SILValue address) {
   return FindAccessBaseVisitor(NestedAccessType::IgnoreAccessBegin,
                                IgnoreStorageCast)
-      .findBase(address);
+      .findPossibleBaseAddress(address);
 }
 
 static bool isLetForBase(SILValue base) {
@@ -510,6 +537,12 @@ void AccessRepresentation::print(raw_ostream &os) const {
 //                              MARK: AccessBase
 //===----------------------------------------------------------------------===//
 
+AccessBase AccessBase::compute(SILValue sourceAddress) {
+  return FindAccessBaseVisitor(NestedAccessType::IgnoreAccessBegin,
+                               IgnoreStorageCast)
+      .findBase(sourceAddress);
+}
+
 AccessBase::AccessBase(SILValue base, Kind kind)
   : AccessRepresentation(base, kind)
 {
@@ -609,6 +642,30 @@ const ValueDecl *AccessBase::getDecl() const {
   }
 }
 
+bool AccessBase::hasLocalOwnershipLifetime() const {
+  switch (getKind()) {
+  case AccessBase::Argument:
+  case AccessBase::Stack:
+  case AccessBase::Global:
+    return false;
+  case AccessBase::Unidentified:
+    // Unidentified storage may be nested within object access, but this is an
+    // "escaped pointer", so it is not restricted to the object's borrow scope.
+    return false;
+  case AccessBase::Yield:
+    // Yielded values have a local apply scope, but they never have the same
+    // storage as yielded values from a different scope, so there is no need to
+    // consider their local scope during substitution.
+    return false;
+  case AccessBase::Box:
+  case AccessBase::Class:
+  case AccessBase::Tail:
+    return getReference()->getOwnershipKind() != OwnershipKind::None;
+  case AccessBase::Nested:
+    llvm_unreachable("unexpected storage");
+  };
+}
+
 void AccessBase::print(raw_ostream &os) const {
   AccessRepresentation::print(os);
   switch (getKind()) {
@@ -675,12 +732,8 @@ namespace {
 // Essentially RC identity where the starting point is already a reference.
 class FindReferenceRoot {
   SmallPtrSet<SILPhiArgument *, 4> visitedPhis;
-  bool preserveOwnership;
 
 public:
-  FindReferenceRoot(bool preserveOwnership)
-      : preserveOwnership(preserveOwnership) {}
-
   SILValue findRoot(SILValue ref) && {
     SILValue root = recursiveFindRoot(ref);
     assert(root && "all phi inputs must be reachable");
@@ -692,14 +745,8 @@ class FindReferenceRoot {
   SILValue recursiveFindRoot(SILValue ref) {
     while (auto *svi = dyn_cast<SingleValueInstruction>(ref)) {
       // If preserveOwnership is true, stop at the first owned root
-      if (preserveOwnership) {
-        if (!isIdentityAndOwnershipPreservingRefCast(svi)) {
-          break;
-        }
-      } else {
-        if (!isIdentityPreservingRefCast(svi)) {
-          break;
-        }
+      if (!isIdentityPreservingRefCast(svi)) {
+        break;
       }
       ref = svi->getOperand(0);
     };
@@ -735,11 +782,54 @@ class FindReferenceRoot {
 } // end anonymous namespace
 
 SILValue swift::findReferenceRoot(SILValue ref) {
-  return FindReferenceRoot(false /*preserveOwnership*/).findRoot(ref);
+  return FindReferenceRoot().findRoot(ref);
 }
 
+// This does not handle phis because a phis is either a consume or a
+// reborrow. In either case, the phi argument's ownership is independent from
+// the phi itself. The client assumes that the returned root is in the same
+// lifetime or borrow scope of the access.
 SILValue swift::findOwnershipReferenceRoot(SILValue ref) {
-  return FindReferenceRoot(true /*preserveOwnership*/).findRoot(ref);
+  while (auto *svi = dyn_cast<SingleValueInstruction>(ref)) {
+    if (isIdentityAndOwnershipPreservingRefCast(svi)) {
+      ref = svi->getOperand(0);
+      continue;
+    }
+    break;
+  }
+  return ref;
+}
+
+/// Find the first owned aggregate containing the reference, or simply the
+/// reference root if no aggregate is found.
+///
+/// TODO: Add a component path to a ReferenceRoot abstraction and handle
+/// that within FindReferenceRoot.
+SILValue swift::findOwnershipReferenceAggregate(SILValue ref) {
+  SILValue root = ref;
+  while(true) {
+    root = findOwnershipReferenceRoot(root);
+    if (!root)
+      return root;
+    if (isa<FirstArgOwnershipForwardingSingleValueInst>(root)
+        || isa<OwnershipForwardingConversionInst>(root)
+        || isa<OwnershipForwardingSelectEnumInstBase>(root)
+        || isa<OwnershipForwardingMultipleValueInstruction>(root)) {
+      root = root->getDefiningInstruction()->getOperand(0);
+      continue;
+    }
+    if (auto *arg = dyn_cast<SILArgument>(root)) {
+      if (auto *term = arg->getSingleTerminator()) {
+        if (term->isTransformationTerminator()) {
+          assert(OwnershipForwardingTermInst::isa(term));
+          root = term->getOperand(0);
+          continue;
+        }
+      }
+    }
+    break;
+  }
+  return root;
 }
 
 //===----------------------------------------------------------------------===//
@@ -802,17 +892,6 @@ void AccessStorage::visitRoots(
   }
 }
 
-bool AccessStorage::isGuaranteedForFunction() const {
-  if (getKind() == AccessStorage::Argument) {
-    return getArgument()->getArgumentConvention().isGuaranteedConvention();
-  }
-  if (isObjectAccess()) {
-    return getRoot().getOwnershipKind() == OwnershipKind::Guaranteed
-           && isa<SILFunctionArgument>(getRoot());
-  }
-  return false;
-}
-
 const ValueDecl *AccessStorage::getDecl() const {
   switch (getKind()) {
   case Box: