[polly] [llvm] [AST] Don't merge memory locations in AliasSetTracker (PR #65731)

[Bruno De Fraine via llvm-commits]

================
@@ -317,62 +262,67 @@ AliasSet *AliasSetTracker::findAliasSetForUnknownInst(Instruction *Inst) {
 }
 
 AliasSet &AliasSetTracker::getAliasSetFor(const MemoryLocation &MemLoc) {
+  // The alias sets are indexed with a map from the memory locations' pointer
+  // values. If the memory location is already registered, we can find it in the
+  // alias set associated with its pointer.
+  AliasSet *&MapEntry = PointerMap[MemLoc.Ptr];
+  if (MapEntry) {
+    AliasSet *AS = MapEntry->getForwardedTarget(*this);
+    if (llvm::is_contained(AS->MemoryLocs, MemLoc)) {
+      if (AS != MapEntry) {
+        AS->addRef();
+        MapEntry->dropRef(*this);
+        MapEntry = AS;
+      }
+      return *AS;
+    }
+  }
 
-  Value * const Pointer = const_cast<Value*>(MemLoc.Ptr);
-  const LocationSize Size = MemLoc.Size;
-  const AAMDNodes &AAInfo = MemLoc.AATags;
-
-  AliasSet::PointerRec &Entry = getEntryFor(Pointer);
-
+  AliasSet *AS;
+  bool MustAliasAll = false;
   if (AliasAnyAS) {
     // At this point, the AST is saturated, so we only have one active alias
     // set. That means we already know which alias set we want to return, and
     // just need to add the pointer to that set to keep the data structure
     // consistent.
     // This, of course, means that we will never need a merge here.
-    if (Entry.hasAliasSet()) {
-      Entry.updateSizeAndAAInfo(Size, AAInfo);
-      assert(Entry.getAliasSet(*this) == AliasAnyAS &&
-             "Entry in saturated AST must belong to only alias set");
-    } else {
-      AliasAnyAS->addPointer(*this, Entry, Size, AAInfo);
-    }
-    return *AliasAnyAS;
+    AS = AliasAnyAS;
+  } else if (AliasSet *AliasAS =
+                 mergeAliasSetsForPointer(MemLoc, MustAliasAll)) {
----------------
brunodf-snps wrote:

No, because adding a new memory location may merge existing alias sets.

Suppose we first add memory location (%p, 2) (notation meaning a memory location with pointer value %p and location size 2). Then we add memory location (%p+2, 2). These memory locations are not aliasing and will be in different alias sets. Then we add memory location (%p, 4). The map entry for %p is pointing to the alias set of (%p, 2) but the memory location is also aliasing with the alias set of (%p+2, 2). mergeAliasSetsForPointer is needed to merge the alias sets, and we add the new memory location to the merged set that it returns.

In the process of merging, one of the original alias sets will become empty and forward to the other. A bit lower in the code, we do verify that the map entry, after following possible forwarding, must end up in the same merged alias set.

https://github.com/llvm/llvm-project/pull/65731