Merge pull request #41806 from nate-chandler/mem_access_utils/two-new-utilities

[MemAccessUtils] Add two utilties.

Author: nate-chandler

include/swift/SIL/MemAccessUtils.h

@@ -260,6 +260,16 @@ enum class NestedAccessType { StopAtAccessBegin, IgnoreAccessBegin };
 /// previous.
 enum class AccessUseType { Exact, Inner, Overlapping };
 
+/// When walking from a value to its storage, casts may be encountered.  The
+/// cases describe variety of encountered casts, categorized by the kind of
+/// transformation that the casts perform.
+///
+/// The enum values are ordered.  Each successive cast kind is more
+/// transformative than the last.
+///
+/// TODO: Distinguish between LayoutEquivalent and LayoutCompatibile.
+enum class AccessStorageCast { Identity, Type };
+
 /// The physical representation used to identify access information and common
 /// API used by both AccessBase and AccessStorage.
 ///
@@ -898,6 +908,30 @@ struct AccessStorageWithBase {
   void dump() const;
 };
 
+/// Extends AccessStorageWithBase by adding information that was obtained while
+/// visiting from a particular address, to which an instance of this is
+/// relative.
+struct RelativeAccessStorageWithBase {
+
+  /// Identical to AccessStorageWithBase::compute but preserves information
+  /// specific to the walk from address;
+  static RelativeAccessStorageWithBase compute(SILValue address);
+
+  /// Identical to AccessStorageWithBase::computeInScope but preserves
+  /// information specific to the walk from address;
+  static RelativeAccessStorageWithBase computeInScope(SILValue address);
+
+  /// The address to which this RelativeAccessStorageWithBase is relative.
+  SILValue address;
+  /// The underlying access storage and base.
+  AccessStorageWithBase storageWithBase;
+  /// The most transformative cast that was seen between when walking from
+  /// address to storage.base;
+  Optional<AccessStorageCast> cast;
+
+  AccessStorage getStorage() const { return storageWithBase.storage; }
+};
+
 /// Return an AccessStorage value that identifies formally accessed storage
 /// for \p beginAccess, considering any outer access scope as having distinct
 /// storage from this access scope. This is useful for exclusivity checking
@@ -1209,6 +1243,16 @@ struct AccessPathWithBase {
   void dump() const;
 };
 
+// Visits all the "product leaves" of the type tree of the specified value and
+// invokes provided visitor, identifying the leaf by its path node and
+// providing its type.
+//
+// The "product leaves" are the leaves obtained by only looking through type
+// products (structs and tuples) and NOT type sums (enums).
+void visitProductLeafAccessPathNodes(
+    SILValue address, TypeExpansionContext tec, SILModule &module,
+    std::function<void(AccessPath::PathNode, SILType)> visitor);
+
 inline AccessPath AccessPath::compute(SILValue address) {
   return AccessPathWithBase::compute(address).accessPath;
 }
@@ -1267,6 +1311,18 @@ template <> struct DenseMapInfo<swift::AccessPathWithBase> {
   }
 };
 
+// Allow AccessPath::PathNode to be used as a pointer-like template argument.
+template<>
+struct PointerLikeTypeTraits<swift::AccessPath::PathNode> {
+  static inline void *getAsVoidPointer(swift::AccessPath::PathNode node) {
+    return (void *)node.node;
+  }
+  static inline swift::AccessPath::PathNode getFromVoidPointer(void *pointer) {
+    return swift::AccessPath::PathNode((swift::IndexTrieNode *)pointer);
+  }
+  enum { NumLowBitsAvailable =
+         PointerLikeTypeTraits<swift::IndexTrieNode *>::NumLowBitsAvailable };
+};
 } // end namespace llvm
 
 //===----------------------------------------------------------------------===//
@@ -1501,28 +1557,14 @@ inline Operand *getAccessProjectionOperand(SingleValueInstruction *svi) {
   };
 }
 
-/// An address, pointer, or box cast that occurs outside of the formal
-/// access. These convert the base of accessed storage without affecting the
-/// AccessPath. Useful for both use-def and def-use traversal. The source
-/// address must be at operand(0).
-///
-/// Some of these casts, such as address_to_pointer, may also occur inside of a
-/// formal access.
-///
-/// TODO: Add stricter structural guarantee such that these never
-/// occur within an access. It's important to be able to get the accessed
-/// address without looking though type casts or pointer_to_address [strict],
-/// which we can't do if those operations are behind access projections.
-inline bool isAccessStorageCast(SingleValueInstruction *svi) {
+/// A cast for the purposes of AccessStorage which may change the
+/// underlying type but doesn't affect the AccessPath.  See isAccessStorageCast.
+inline bool isAccessStorageTypeCast(SingleValueInstruction *svi) {
   switch (svi->getKind()) {
   default:
     return false;
-
-  // Simply pass-thru the incoming address.
-  case SILInstructionKind::MarkUninitializedInst:
+  // Simply pass-thru the incoming address.  But change its type!
   case SILInstructionKind::UncheckedAddrCastInst:
-  case SILInstructionKind::MarkDependenceInst:
-  case SILInstructionKind::CopyValueInst:
   // Casting to RawPointer does not affect the AccessPath. When converting
   // between address types, they must be layout compatible (with truncation).
   case SILInstructionKind::AddressToPointerInst:
@@ -1552,6 +1594,37 @@ inline bool isAccessStorageCast(SingleValueInstruction *svi) {
   }
 }
 
+/// A cast for the purposes of AccessStorage which doesn't change the
+/// underlying type and doesn't affect the AccessPath.  See isAccessStorageCast.
+inline bool isAccessStorageIdentityCast(SingleValueInstruction *svi) {
+  switch (svi->getKind()) {
+  default:
+    return false;
+
+  // Simply pass-thru the incoming address.
+  case SILInstructionKind::MarkUninitializedInst:
+  case SILInstructionKind::MarkDependenceInst:
+  case SILInstructionKind::CopyValueInst:
+    return true;
+  }
+}
+
+/// An address, pointer, or box cast that occurs outside of the formal
+/// access. These convert the base of accessed storage without affecting the
+/// AccessPath. Useful for both use-def and def-use traversal. The source
+/// address must be at operand(0).
+///
+/// Some of these casts, such as address_to_pointer, may also occur inside of a
+/// formal access.
+///
+/// TODO: Add stricter structural guarantee such that these never
+/// occur within an access. It's important to be able to get the accessed
+/// address without looking though type casts or pointer_to_address [strict],
+/// which we can't do if those operations are behind access projections.
+inline bool isAccessStorageCast(SingleValueInstruction *svi) {
+  return isAccessStorageTypeCast(svi) || isAccessStorageIdentityCast(svi);
+}
+
 /// Abstract CRTP class for a visiting instructions that are part of the use-def
 /// chain from an accessed address up to the storage base.
 ///
@@ -1598,8 +1671,9 @@ class AccessUseDefChainVisitor {
   // Result visitBase(SILValue base, AccessStorage::Kind kind);
   // Result visitNonAccess(SILValue base);
   // Result visitPhi(SILPhiArgument *phi);
-  // Result visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper);
-  // Result visitAccessProjection(SingleValueInstruction *projectedAddr,
+  // Result visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper,
+  // AccessStorageCast cast); Result
+  // visitAccessProjection(SingleValueInstruction *projectedAddr,
   //                              Operand *sourceOper);
 
   Result visit(SILValue sourceAddr);
@@ -1611,8 +1685,12 @@ Result AccessUseDefChainVisitor<Impl, Result>::visit(SILValue sourceAddr) {
     if (auto *projOper = getAccessProjectionOperand(svi))
       return asImpl().visitAccessProjection(svi, projOper);
 
-    if (isAccessStorageCast(svi))
-      return asImpl().visitStorageCast(svi, &svi->getAllOperands()[0]);
+    if (isAccessStorageTypeCast(svi))
+      return asImpl().visitStorageCast(svi, &svi->getAllOperands()[0],
+                                       AccessStorageCast::Type);
+    if (isAccessStorageIdentityCast(svi))
+      return asImpl().visitStorageCast(svi, &svi->getAllOperands()[0],
+                                       AccessStorageCast::Identity);
   }
   switch (sourceAddr->getKind()) {
   default:
@@ -1787,7 +1865,8 @@ class AccessUseDefChainCloner
     return SILValue();
   }
 
-  SILValue visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper) {
+  SILValue visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper,
+                            AccessStorageCast) {
     // The cloner does not currently know how to create compensating
     // end_borrows or fix mark_dependence operands.
     if (isa<BeginBorrowInst>(cast) || isa<MarkDependenceInst>(cast))

include/swift/SIL/MemoryLocations.h

@@ -238,14 +238,14 @@ class MemoryLocations {
     addr2LocIdx[projection] = locIdx;
   }
 
-  /// Sets the location bits os \p addr in \p bits, if \p addr is associated
+  /// Sets the location bits of \p addr in \p bits, if \p addr is associated
   /// with a location.
   void setBits(Bits &bits, SILValue addr) const {
     if (auto *loc = getLocation(addr))
       bits |= loc->subLocations;
   }
 
-  /// Clears the location bits os \p addr in \p bits, if \p addr is associated
+  /// Clears the location bits of \p addr in \p bits, if \p addr is associated
   /// with a location.
   void clearBits(Bits &bits, SILValue addr) const {
     if (auto *loc = getLocation(addr))
@@ -307,7 +307,7 @@ class MemoryLocations {
                                       SubLocationMap &subLocationMap);
 
   /// Helper function called by analyzeLocation to create a sub-location for
-  /// and address projection and check all of its uses.
+  /// an address projection and check all of its uses.
   bool analyzeAddrProjection(
     SingleValueInstruction *projection, unsigned parentLocIdx,unsigned fieldNr,
     SmallVectorImpl<SILValue> &collectedVals, SubLocationMap &subLocationMap);

include/swift/SIL/Projection.h

@@ -484,7 +484,7 @@ static_assert(sizeof(Projection) == sizeof(uintptr_t),
 /// The main purpose of this class is to enable one to reason about iterated
 /// chains of projections. Some example usages are:
 ///
-/// 1. Converting value projections to aggregate projections or vis-a-versa.
+/// 1. Converting value projections to aggregate projections or vice versa.
 /// 2. Performing tuple operations on two paths (using the mathematical
 ///    definition of tuples as ordered sets).
 class ProjectionPath {

lib/SIL/IR/SILInstructions.cpp

@@ -75,7 +75,7 @@ static void buildTypeDependentOperands(
     bool hasDynamicSelf, SmallVectorImpl<SILValue> &TypeDependentOperands,
     SILFunction &F) {
 
-  for (const auto archetype : RootOpenedArchetypes) {
+  for (const auto &archetype : RootOpenedArchetypes) {
     SILValue def = F.getModule().getRootOpenedArchetypeDef(archetype, &F);
     assert(def->getFunction() == &F &&
            "def of root opened archetype is in wrong function");

lib/SIL/Utils/MemAccessUtils.cpp

@@ -125,7 +125,8 @@ class AccessPhiVisitor
       phiArg->getIncomingPhiValues(pointerWorklist);
   }
 
-  void visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper) {
+  void visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper,
+                        AccessStorageCast) {
     // Allow conversions to/from pointers and addresses on disjoint phi paths
     // only if the underlying useDefVisitor allows it.
     if (storageCastTy == IgnoreStorageCast)
@@ -209,7 +210,8 @@ class FindAccessVisitorImpl : public AccessUseDefChainVisitor<Impl, SILValue> {
     return this->asImpl().visitNonAccess(phiArg);
   }
 
-  SILValue visitStorageCast(SingleValueInstruction *, Operand *sourceAddr) {
+  SILValue visitStorageCast(SingleValueInstruction *, Operand *sourceAddr,
+                            AccessStorageCast cast) {
     assert(storageCastTy == IgnoreStorageCast);
     return sourceAddr->get();
   }
@@ -331,11 +333,12 @@ class FindAccessBaseVisitor
   }
 
   // Override visitStorageCast to avoid seeing through arbitrary address casts.
-  SILValue visitStorageCast(SingleValueInstruction *cast, Operand *sourceAddr) {
+  SILValue visitStorageCast(SingleValueInstruction *svi, Operand *sourceAddr,
+                            AccessStorageCast cast) {
     if (storageCastTy == StopAtStorageCast)
-      return visitNonAccess(cast);
+      return visitNonAccess(svi);
 
-    return SuperTy::visitStorageCast(cast, sourceAddr);
+    return SuperTy::visitStorageCast(svi, sourceAddr, cast);
   }
 };
 
@@ -1062,11 +1065,13 @@ namespace {
 // AccessStorage object for all projection paths.
 class FindAccessStorageVisitor
     : public FindAccessVisitorImpl<FindAccessStorageVisitor> {
+  using SuperTy = FindAccessVisitorImpl<FindAccessStorageVisitor>;
 
 public:
   struct Result {
     Optional<AccessStorage> storage;
     SILValue base;
+    Optional<AccessStorageCast> seenCast;
   };
 
 private:
@@ -1102,6 +1107,8 @@ class FindAccessStorageVisitor
   // may be multiple global_addr bases for identical storage.
   SILValue getBase() const { return result.base; }
 
+  Optional<AccessStorageCast> getCast() const { return result.seenCast; }
+
   // MARK: AccessPhiVisitor::UseDefVisitor implementation.
 
   // A valid result requires valid storage, but not a valid base.
@@ -1128,22 +1135,41 @@ class FindAccessStorageVisitor
     invalidateResult();
     return SILValue();
   }
+
+  SILValue visitStorageCast(SingleValueInstruction *svi, Operand *sourceOper,
+                            AccessStorageCast cast) {
+    result.seenCast = result.seenCast ? std::max(*result.seenCast, cast) : cast;
+    return SuperTy::visitStorageCast(svi, sourceOper, cast);
+  }
 };
 
 } // end anonymous namespace
 
+RelativeAccessStorageWithBase
+RelativeAccessStorageWithBase::compute(SILValue address) {
+  FindAccessStorageVisitor visitor(NestedAccessType::IgnoreAccessBegin);
+  visitor.findStorage(address);
+  return {
+      address, {visitor.getStorage(), visitor.getBase()}, visitor.getCast()};
+}
+
+RelativeAccessStorageWithBase
+RelativeAccessStorageWithBase::computeInScope(SILValue address) {
+  FindAccessStorageVisitor visitor(NestedAccessType::StopAtAccessBegin);
+  visitor.findStorage(address);
+  return {
+      address, {visitor.getStorage(), visitor.getBase()}, visitor.getCast()};
+}
+
 AccessStorageWithBase
 AccessStorageWithBase::compute(SILValue sourceAddress) {
-  FindAccessStorageVisitor visitor(NestedAccessType::IgnoreAccessBegin);
-  visitor.findStorage(sourceAddress);
-  return {visitor.getStorage(), visitor.getBase()};
+  return RelativeAccessStorageWithBase::compute(sourceAddress).storageWithBase;
 }
 
 AccessStorageWithBase
 AccessStorageWithBase::computeInScope(SILValue sourceAddress) {
-  FindAccessStorageVisitor visitor(NestedAccessType::StopAtAccessBegin);
-  visitor.findStorage(sourceAddress);
-  return {visitor.getStorage(), visitor.getBase()};
+  return RelativeAccessStorageWithBase::computeInScope(sourceAddress)
+      .storageWithBase;
 }
 
 AccessStorage AccessStorage::compute(SILValue sourceAddress) {
@@ -1357,6 +1383,36 @@ AccessPathWithBase AccessPathWithBase::computeInScope(SILValue address) {
       .findAccessPath(address);
 }
 
+void swift::visitProductLeafAccessPathNodes(
+    SILValue address, TypeExpansionContext tec, SILModule &module,
+    std::function<void(AccessPath::PathNode, SILType)> visitor) {
+  SmallVector<std::pair<SILType, IndexTrieNode *>, 32> worklist;
+  auto rootPath = AccessPath::compute(address);
+  auto *node = rootPath.getPathNode().node;
+  worklist.push_back({address->getType(), node});
+  while (!worklist.empty()) {
+    auto pair = worklist.pop_back_val();
+    auto silType = pair.first;
+    auto *node = pair.second;
+    if (auto tupleType = silType.getAs<TupleType>()) {
+      for (unsigned index : indices(tupleType->getElements())) {
+        auto *elementNode = node->getChild(index);
+        worklist.push_back({silType.getTupleElementType(index), elementNode});
+      }
+    } else if (auto *decl = silType.getStructOrBoundGenericStruct()) {
+      unsigned index = 0;
+      for (auto *field : decl->getStoredProperties()) {
+        auto *fieldNode = node->getChild(index);
+        worklist.push_back(
+            {silType.getFieldType(field, module, tec), fieldNode});
+        ++index;
+      }
+    } else {
+      visitor(AccessPath::PathNode(node), silType);
+    }
+  }
+}
+
 void AccessPath::Index::print(raw_ostream &os) const {
   if (isSubObjectProjection())
     os << '#' << getSubObjectIndex();

lib/SILOptimizer/SemanticARC/LoadCopyToLoadBorrowOpt.cpp

@@ -264,7 +264,7 @@ class StorageGuaranteesLoadVisitor
   }
 
   void visitStorageCast(SingleValueInstruction *projectedAddr,
-                        Operand *parentAddr) {
+                        Operand *parentAddr, AccessStorageCast cast) {
     return next(parentAddr->get());
   }