Simplify definition and usage of getForwardedTarget

Integrate this private method with updating the map entry in unified
procedure.

Author: brunodf-snps

llvm/include/llvm/Analysis/AliasSetTracker.h

@@ -139,21 +139,6 @@ class AliasSet : public ilist_node<AliasSet> {
   AliasSet()
       : RefCount(0), AliasAny(false), Access(NoAccess), Alias(SetMustAlias) {}
 
-  /// Return the real alias set this represents. If this has been merged with
-  /// another set and is forwarding, return the ultimate destination set. This
-  /// also implements the union-find collapsing as well.
-  AliasSet *getForwardedTarget(AliasSetTracker &AST) {
-    if (!Forward) return this;
-
-    AliasSet *Dest = Forward->getForwardedTarget(AST);
-    if (Dest != Forward) {
-      Dest->addRef();
-      Forward->dropRef(AST);
-      Forward = Dest;
-    }
-    return Dest;
-  }
-
   void removeFromTracker(AliasSetTracker &AST);
 
   void addPointer(AliasSetTracker &AST, const MemoryLocation &MemLoc,
@@ -251,6 +236,23 @@ class AliasSetTracker {
 
   void removeAliasSet(AliasSet *AS);
 
+  // Update an alias set field to point to its real destination. If the field is
+  // pointing to a set that has been merged with another set and is forwarding,
+  // the field is updated to point to the set obtained by following the
+  // forwarding links. The Forward fields of intermediate alias sets are
+  // collapsed as well, and alias set reference counts are updated to reflect
+  // the new situation.
+  void collapseForwardingIn(AliasSet *&AS) {
+    if (AS->Forward) {
+      collapseForwardingIn(AS->Forward);
+      // Swap out AS for AS->Forward, while updating reference counts.
+      AliasSet *NewAS = AS->Forward;
+      NewAS->addRef();
+      AS->dropRef(*this);
+      AS = NewAS;
+    }
+  }
+
   AliasSet &addPointer(MemoryLocation Loc, AliasSet::AccessLattice E);
   AliasSet *mergeAliasSetsForPointer(const MemoryLocation &MemLoc,
                                      AliasSet *PtrAS, bool &MustAliasAll);

llvm/lib/Analysis/AliasSetTracker.cpp

@@ -276,15 +276,9 @@ AliasSet &AliasSetTracker::getAliasSetFor(const MemoryLocation &MemLoc) {
   // alias set associated with its pointer.
   AliasSet *&MapEntry = PointerMap[MemLoc.Ptr];
   if (MapEntry) {
-    AliasSet *AS = MapEntry->getForwardedTarget(*this);
-    if (is_contained(AS->MemoryLocs, MemLoc)) {
-      if (AS != MapEntry) {
-        AS->addRef();
-        MapEntry->dropRef(*this);
-        MapEntry = AS;
-      }
-      return *AS;
-    }
+    collapseForwardingIn(MapEntry);
+    if (is_contained(MapEntry->MemoryLocs, MemLoc))
+      return *MapEntry;
   }
 
   AliasSet *AS;
@@ -296,10 +290,8 @@ AliasSet &AliasSetTracker::getAliasSetFor(const MemoryLocation &MemLoc) {
     // consistent.
     // This, of course, means that we will never need a merge here.
     AS = AliasAnyAS;
-  } else if (AliasSet *AliasAS = mergeAliasSetsForPointer(
-                 MemLoc,
-                 MapEntry ? MapEntry->getForwardedTarget(*this) : nullptr,
-                 MustAliasAll)) {
+  } else if (AliasSet *AliasAS =
+                 mergeAliasSetsForPointer(MemLoc, MapEntry, MustAliasAll)) {
     // Add it to the alias set it aliases.
     AS = AliasAS;
   } else {
@@ -313,12 +305,7 @@ AliasSet &AliasSetTracker::getAliasSetFor(const MemoryLocation &MemLoc) {
   // Register selected alias set in pointer map (or ensure it is consistent with
   // earlier map entry after taking into account new merging).
   if (MapEntry) {
-    if (MapEntry->Forward) {
-      AliasSet *NewAS = MapEntry->getForwardedTarget(*this);
-      NewAS->addRef();
-      MapEntry->dropRef(*this);
-      MapEntry = NewAS;
-    }
+    collapseForwardingIn(MapEntry);
     assert(MapEntry == AS && "Memory locations with same pointer value cannot "
                              "be in different alias sets");
   } else {