[MemAccessUtils] Added RelativeAccessStorageWithBase.

The new "relative" version of AccessStorageWithBase carries additional
information about the walk from the specified address back to the base.
For now, that includes the original address and the most transformative
sort of cast that was encountered.

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
@@ -1637,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);
@@ -1650,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:
@@ -1826,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))

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) {

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());
   }