ScopInfo: Check for the existance of a single memory accesses

Instead of counting all array memory accesses associated with a load
instruction, we now explicitly check that the single array access that could
(potentially) be associated with a load instruction does not exist. This helps
to document the current behavior of Polly where load instructions can indeed
have at most one associated array access. In the unlikely case this changes
in the future, we add an assert for the case where two load accesses would
prevent us to return a single memory access, but we still should communicate
that not all array memory accesses have been removed.

This addresses post-commit comments from Johannes Doerfert for commit 255776.

llvm-svn: 256136

diff --git a/polly/include/polly/ScopInfo.h b/polly/include/polly/ScopInfo.h
index d70d13d..0252599 100644 (file)
--- a/polly/include/polly/ScopInfo.h
+++ b/polly/include/polly/ScopInfo.h
@@ -958,14 +958,15 @@ public:
   /// @brief Return true if this statement does not contain any accesses.
   bool isEmpty() const { return MemAccs.empty(); }
 
-  /// @brief Return the only array access for @p Inst.
+  /// @brief Return the only array access for @p Inst, if existing.
   ///
   /// @param Inst The instruction for which to look up the access.
-  /// @returns The unique array memory access related to Inst.
-  MemoryAccess &getArrayAccessFor(const Instruction *Inst) const {
+  /// @returns The unique array memory access related to Inst or nullptr if
+  ///          no array access exists
+  MemoryAccess *getArrayAccessOrNULLFor(const Instruction *Inst) const {
     auto It = InstructionToAccess.find(Inst);
-    assert(It != InstructionToAccess.end() &&
-           "No memory accesses found for instruction");
+    if (It == InstructionToAccess.end())
+      return nullptr;
 
     MemoryAccess *ArrayAccess = nullptr;
 
@@ -978,26 +979,18 @@ public:
       ArrayAccess = Access;
     }
 
-    assert(ArrayAccess && "No array access found for instruction!");
-    return *ArrayAccess;
+    return ArrayAccess;
   }
 
-  /// @brief Get the number of array accesses associated with an instruction.
+  /// @brief Return the only array access for @p Inst.
   ///
-  /// @param Inst The instruction for which to obtain the access count.
-  /// @returns The number of array accesses associated with this instruction.
-  size_t getNumberOfArrayAccessesFor(const Instruction *Inst) const {
-    size_t NumAccesses = 0;
-    auto It = InstructionToAccess.find(Inst);
-    if (It == InstructionToAccess.end())
-      return 0;
-
-    for (auto Access : It->getSecond()) {
-      if (Access->isArrayKind())
-        NumAccesses++;
-    }
+  /// @param Inst The instruction for which to look up the access.
+  /// @returns The unique array memory access related to Inst.
+  MemoryAccess &getArrayAccessFor(const Instruction *Inst) const {
+    MemoryAccess *ArrayAccess = getArrayAccessOrNULLFor(Inst);
 
-    return NumAccesses;
+    assert(ArrayAccess && "No array access found for instruction!");
+    return *ArrayAccess;
   }
 
   void setBasicBlock(BasicBlock *Block) {

diff --git a/polly/lib/Analysis/ScopInfo.cpp b/polly/lib/Analysis/ScopInfo.cpp
index e98218a..94e9dee 100644 (file)
--- a/polly/lib/Analysis/ScopInfo.cpp
+++ b/polly/lib/Analysis/ScopInfo.cpp
@@ -2928,7 +2928,7 @@ void Scop::verifyInvariantLoads() {
   for (LoadInst *LI : RIL) {
     assert(LI && getRegion().contains(LI));
     ScopStmt *Stmt = getStmtForBasicBlock(LI->getParent());
-    if (Stmt && Stmt->getNumberOfArrayAccessesFor(LI) > 0) {
+    if (Stmt && Stmt->getArrayAccessOrNULLFor(LI)) {
       invalidate(INVARIANTLOAD, LI->getDebugLoc());
       return;
     }