MemAccessUtils cleanup: rename hasIdenticalBase

to hasIdenticalStorage.

Be precise in preparation for unifying and clarifying the access base model.

Author: atrick

include/swift/SIL/MemAccessUtils.h

@@ -485,7 +485,7 @@ class AccessedStorage {
   /// This compares only the AccessedStorage base class bits, ignoring the
   /// subclass bits. It is used for hash lookup equality, so it should not
   /// perform any additional lookups or dereference memory outside itself.
-  bool hasIdenticalBase(const AccessedStorage &other) const {
+  bool hasIdenticalStorage(const AccessedStorage &other) const {
     if (getKind() != other.getKind())
       return false;
 
@@ -609,7 +609,7 @@ class AccessedStorage {
   template <bool (AccessedStorage::*IsUniqueFn)() const>
   bool isDistinctFrom(const AccessedStorage &other) const {
     if ((this->*IsUniqueFn)()) {
-      if ((other.*IsUniqueFn)() && !hasIdenticalBase(other))
+      if ((other.*IsUniqueFn)() && !hasIdenticalStorage(other))
         return true;
 
       if (other.isObjectAccess())
@@ -706,7 +706,7 @@ template <> struct DenseMapInfo<swift::AccessedStorage> {
   }
 
   static bool isEqual(swift::AccessedStorage LHS, swift::AccessedStorage RHS) {
-    return LHS.hasIdenticalBase(RHS);
+    return LHS.hasIdenticalStorage(RHS);
   }
 };
 
@@ -944,8 +944,9 @@ class AccessPath {
 
   bool operator==(AccessPath other) const {
     return
-      storage.hasIdenticalBase(other.storage) && pathNode == other.pathNode &&
-      offset == other.offset;
+      storage.hasIdenticalStorage(other.storage)
+      && pathNode == other.pathNode
+      && offset == other.offset;
   }
   bool operator!=(AccessPath other) const { return !(*this == other); }
 
@@ -1220,8 +1221,8 @@ void checkSwitchEnumBlockArg(SILPhiArgument *arg);
 /// This is not a member of AccessedStorage because it only makes sense to use
 /// in SILGen before access markers are emitted, or when verifying access
 /// markers.
-bool isPossibleFormalAccessBase(const AccessedStorage &storage,
-                                SILFunction *F);
+bool isPossibleFormalAccessStorage(const AccessedStorage &storage,
+                                   SILFunction *F);
 
 /// Perform a RAUW operation on begin_access with it's own source operand.
 /// Then erase the begin_access and all associated end_access instructions.

lib/SIL/Utils/MemAccessUtils.cpp

@@ -689,7 +689,7 @@ class FindAccessedStorageVisitor
       // `storage` may still be invalid. If both `storage` and `foundStorage`
       // are invalid, this check passes, but we return an invalid storage
       // below.
-      if (!result.storage->hasIdenticalBase(foundStorage))
+      if (!result.storage->hasIdenticalStorage(foundStorage))
         result.storage = AccessedStorage();
       if (result.base != foundBase)
         result.base = SILValue();
@@ -777,7 +777,7 @@ bool AccessPath::contains(AccessPath subPath) const {
   if (!isValid() || !subPath.isValid()) {
     return false;
   }
-  if (!storage.hasIdenticalBase(subPath.storage)) {
+  if (!storage.hasIdenticalStorage(subPath.storage)) {
     return false;
   }
   // Does the offset index match?
@@ -1228,7 +1228,7 @@ bool AccessPathDefUseTraversal::pushPhiUses(const SILPhiArgument *phi,
   // looking through it. If the phi input differ the its storage is invalid.
   auto phiPath = AccessPath::compute(phi);
   if (phiPath.isValid()) {
-    assert(phiPath.getStorage().hasIdenticalBase(storage)
+    assert(phiPath.getStorage().hasIdenticalStorage(storage)
            && "inconsistent phi storage");
     // If the phi paths have different offsets, its path has unknown offset.
     if (phiPath.getOffset() == AccessPath::UnknownOffset) {
@@ -1699,8 +1699,8 @@ void swift::checkSwitchEnumBlockArg(SILPhiArgument *arg) {
   }
 }
 
-bool swift::isPossibleFormalAccessBase(const AccessedStorage &storage,
-                                       SILFunction *F) {
+bool swift::isPossibleFormalAccessStorage(const AccessedStorage &storage,
+                                          SILFunction *F) {
   switch (storage.getKind()) {
   case AccessedStorage::Nested:
     assert(false && "don't pass nested storage to this helper");

lib/SILGen/SILGenLValue.cpp

@@ -619,7 +619,7 @@ SILValue UnenforcedAccess::beginAccess(SILGenFunction &SGF, SILLocation loc,
 
   auto storage = AccessedStorage::compute(address);
   // Unsafe access may have invalid storage (e.g. a RawPointer).
-  if (storage && !isPossibleFormalAccessBase(storage, &SGF.F))
+  if (storage && !isPossibleFormalAccessStorage(storage, &SGF.F))
     return address;
 
   auto BAI =

lib/SILOptimizer/Mandatory/DiagnoseStaticExclusivity.cpp

@@ -1034,7 +1034,7 @@ static void checkAccessedAddress(Operand *memOper, StorageMap &Accesses) {
 
   // Some identifiable addresses can also be recognized as local initialization
   // or other patterns that don't qualify as formal access.
-  if (!isPossibleFormalAccessBase(storage, memInst->getFunction()))
+  if (!isPossibleFormalAccessStorage(storage, memInst->getFunction()))
     return;
 
   // A box or stack variable may represent lvalues, but they can only conflict

lib/SILOptimizer/Transforms/AccessEnforcementOpts.cpp

@@ -428,7 +428,7 @@ BeginAccessInst *AccessConflictAndMergeAnalysis::findMergeableOutOfScopeAccess(
   auto identicalStorageIter = llvm::find_if(
       state.outOfScopeConflictFreeAccesses, [&](BeginAccessInst *bai) {
         auto storageInfo = result.getAccessInfo(bai);
-        return storageInfo.hasIdenticalBase(currStorageInfo);
+        return storageInfo.hasIdenticalStorage(currStorageInfo);
       });
   if (identicalStorageIter == state.outOfScopeConflictFreeAccesses.end())
     return nullptr;
@@ -484,7 +484,7 @@ void AccessConflictAndMergeAnalysis::insertOutOfScopeAccess(
   auto identicalStorageIter = llvm::find_if(
       state.outOfScopeConflictFreeAccesses, [&](BeginAccessInst *bai) {
         auto storageInfo = result.getAccessInfo(bai);
-        return storageInfo.hasIdenticalBase(currStorageInfo);
+        return storageInfo.hasIdenticalStorage(currStorageInfo);
       });
   if (identicalStorageIter == state.outOfScopeConflictFreeAccesses.end())
     state.outOfScopeConflictFreeAccesses.insert(beginAccess);