Introduce getPointers method

For clients that want to iterate the deduplicated pointers. Also
consistently distinguish memory location vs. pointer iteration.

Author: brunodf-snps

llvm/include/llvm/Analysis/AliasSetTracker.h

@@ -20,6 +20,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/Analysis/MemoryLocation.h"
@@ -116,14 +117,20 @@ class AliasSet : public ilist_node<AliasSet> {
   /// Merge the specified alias set into this alias set.
   void mergeSetIn(AliasSet &AS, AliasSetTracker &AST, BatchAAResults &BatchAA);
 
-  // Alias Set iteration - Allow access to all of the pointers which are part of
-  // this alias set.
+  // Alias Set iteration - Allow access to all of the memory locations which are
+  // part of this alias set.
   using iterator = std::vector<MemoryLocation>::const_iterator;
   iterator begin() const { return MemoryLocs.begin(); }
   iterator end() const { return MemoryLocs.end(); }
 
   unsigned size() { return MemoryLocs.size(); }
 
+  /// Retrieve the pointer values for the memory locations in this alias set.
+  /// The order matches that of the memory locations, but duplicate pointer
+  /// values are omitted.
+  using PointerVector = SmallVector<const Value *, 8>;
+  PointerVector getPointers() const;
+
   void print(raw_ostream &OS) const;
   void dump() const;
 

llvm/lib/Analysis/AliasSetTracker.cpp

@@ -207,6 +207,25 @@ ModRefInfo AliasSet::aliasesUnknownInst(const Instruction *Inst,
   return MR;
 }
 
+AliasSet::PointerVector AliasSet::getPointers() const {
+  // To deduplicate pointer values, use a linear scan if the number of elements
+  // is small, or a set if large. This is the same idea as SmallSetVector. In
+  // addition, we can allocate space for the result vector upfront.
+  PointerVector Result;
+  if (MemoryLocs.size() <= Result.capacity()) {
+    for (const MemoryLocation &MemLoc : MemoryLocs)
+      if (llvm::find(Result, MemLoc.Ptr) == Result.end())
+        Result.push_back(MemLoc.Ptr);
+  } else {
+    Result.reserve(MemoryLocs.size());
+    DenseSet<const Value *> Seen;
+    for (const MemoryLocation &MemLoc : MemoryLocs)
+      if (Seen.insert(MemLoc.Ptr).second)
+        Result.push_back(MemLoc.Ptr);
+  }
+  return Result;
+}
+
 void AliasSetTracker::clear() {
   PointerMap.clear();
   AliasSets.clear();

llvm/lib/Analysis/LoopAccessAnalysis.cpp

@@ -1115,6 +1115,7 @@ bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck,
     int NumWritePtrChecks = 0;
     bool CanDoAliasSetRT = true;
     ++ASId;
+    auto ASPointers = AS.getPointers();
 
     // We assign consecutive id to access from different dependence sets.
     // Accesses within the same set don't need a runtime check.
@@ -1126,8 +1127,8 @@ bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck,
     // First, count how many write and read accesses are in the alias set. Also
     // collect MemAccessInfos for later.
     SmallVector<MemAccessInfo, 4> AccessInfos;
-    for (const auto &A : AS) {
-      Value *Ptr = const_cast<Value *>(A.Ptr);
+    for (const Value *Ptr_ : ASPointers) {
+      Value *Ptr = const_cast<Value *>(Ptr_);
       bool IsWrite = Accesses.count(MemAccessInfo(Ptr, true));
       if (IsWrite)
         ++NumWritePtrChecks;
@@ -1140,10 +1141,10 @@ bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck,
     // or a single write and no reads.
     if (NumWritePtrChecks == 0 ||
         (NumWritePtrChecks == 1 && NumReadPtrChecks == 0)) {
-      assert((AS.size() <= 1 ||
-              all_of(AS,
-                     [this](auto AC) {
-                       MemAccessInfo AccessWrite(const_cast<Value *>(AC.Ptr),
+      assert((ASPointers.size() <= 1 ||
+              all_of(ASPointers,
+                     [this](auto Ptr) {
+                       MemAccessInfo AccessWrite(const_cast<Value *>(Ptr),
                                                  true);
                        return DepCands.findValue(AccessWrite) == DepCands.end();
                      })) &&
@@ -1272,8 +1273,9 @@ void AccessAnalysis::processMemAccesses() {
   // set.
   for (const auto &AS : AST) {
     // Note that both the alias-set tracker and the alias sets themselves used
-    // linked lists internally and so the iteration order here is deterministic
-    // (matching the original instruction order within each set).
+    // ordered collections internally and so the iteration order here is
+    // deterministic.
+    auto ASPointers = AS.getPointers();
 
     bool SetHasWrite = false;
 
@@ -1290,8 +1292,8 @@ void AccessAnalysis::processMemAccesses() {
       bool UseDeferred = SetIteration > 0;
       PtrAccessMap &S = UseDeferred ? DeferredAccesses : Accesses;
 
-      for (const auto &AV : AS) {
-        Value *Ptr = const_cast<Value *>(AV.Ptr);
+      for (const Value *Ptr_ : ASPointers) {
+        Value *Ptr = const_cast<Value *>(Ptr_);
 
         // For a single memory access in AliasSetTracker, Accesses may contain
         // both read and write, and they both need to be handled for CheckDeps.

llvm/lib/Transforms/Scalar/LICM.cpp

@@ -2323,8 +2323,8 @@ collectPromotionCandidates(MemorySSA *MSSA, AliasAnalysis *AA, Loop *L) {
   SmallVector<std::pair<SmallSetVector<Value *, 8>, bool>, 0> Result;
   for (auto [Set, HasReadsOutsideSet] : Sets) {
     SmallSetVector<Value *, 8> PointerMustAliases;
-    for (const auto &ASI : *Set)
-      PointerMustAliases.insert(const_cast<Value *>(ASI.Ptr));
+    for (const auto &MemLoc : *Set)
+      PointerMustAliases.insert(const_cast<Value *>(MemLoc.Ptr));
     Result.emplace_back(std::move(PointerMustAliases), HasReadsOutsideSet);
   }
 

llvm/lib/Transforms/Scalar/LoopVersioningLICM.cpp

@@ -263,8 +263,8 @@ bool LoopVersioningLICM::legalLoopMemoryAccesses() {
     // Check for Mod & MayAlias
     HasMayAlias |= AS.isMayAlias();
     HasMod |= AS.isMod();
-    for (const auto &A : AS) {
-      const Value *Ptr = A.Ptr;
+    for (const auto &MemLoc : AS) {
+      const Value *Ptr = MemLoc.Ptr;
       // Alias tracker should have pointers of same data type.
       //
       // FIXME: check no longer effective since opaque pointers?

polly/lib/Analysis/ScopBuilder.cpp

@@ -3255,10 +3255,8 @@ ScopBuilder::buildAliasGroupsForAccesses() {
     if (AS.isMustAlias() || AS.isForwardingAliasSet())
       continue;
     AliasGroupTy AG;
-    llvm::SmallPtrSet<const Value *, 8> Seen;
-    for (auto &MemLoc : AS)
-      if (Seen.insert(MemLoc.Ptr).second)
-        AG.push_back(PtrToAcc[const_cast<Value *>(MemLoc.Ptr)]);
+    for (const Value *Ptr : AS.getPointers())
+      AG.push_back(PtrToAcc[const_cast<Value *>(Ptr)]);
     if (AG.size() < 2)
       continue;
     AliasGroups.push_back(std::move(AG));

polly/lib/Analysis/ScopDetection.cpp

@@ -1149,6 +1149,8 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
       // sure the base pointer is not an instruction defined inside the scop.
       // However, we can ignore loads that will be hoisted.
 
+      auto ASPointers = AS.getPointers();
+
       InvariantLoadsSetTy VariantLS, InvariantLS;
       // In order to detect loads which are dependent on other invariant loads
       // as invariant, we use fixed-point iteration method here i.e we iterate
@@ -1158,9 +1160,8 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
         const unsigned int VariantSize = VariantLS.size(),
                            InvariantSize = InvariantLS.size();
 
-        for (const auto &MemLoc : AS) {
-          Instruction *Inst =
-              dyn_cast<Instruction>(const_cast<Value *>(MemLoc.Ptr));
+        for (const Value *Ptr : ASPointers) {
+          Instruction *Inst = dyn_cast<Instruction>(const_cast<Value *>(Ptr));
           if (Inst && Context.CurRegion.contains(Inst)) {
             auto *Load = dyn_cast<LoadInst>(Inst);
             if (Load && InvariantLS.count(Load))

polly/lib/Analysis/ScopDetectionDiagnostic.cpp

@@ -638,9 +638,7 @@ bool ReportNonSimpleMemoryAccess::classof(const RejectReason *RR) {
 
 ReportAlias::ReportAlias(Instruction *Inst, AliasSet &AS)
     : RejectReason(RejectReasonKind::Alias), Inst(Inst) {
-  for (const auto &I : AS)
-    if (!llvm::is_contained(Pointers, I.Ptr))
-      Pointers.push_back(I.Ptr);
+  llvm::append_range(Pointers, AS.getPointers());
 }
 
 std::string ReportAlias::formatInvalidAlias(std::string Prefix,