Address review comments

* Renamed CountableEarlyExitBlocks -> CountableEarlyExitingBlocks
* Renamed getExactExitingBlocks -> getCountableExitingBlocks
* Updated comments in code.
* Improved analysis/debug message.
* Simplified code in isAnalyzableEarlyExitLoop and
BackedgeTakenInfo::getSpeculative.

Author: david-arm

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

@@ -626,7 +626,7 @@ class LoopAccessInfo {
   /// Returns all blocks with a countable exit, i.e. the exit-not-taken count
   /// is known exactly at compile time.
   const SmallVector<BasicBlock *, 4> &getCountableEarlyExitingBlocks() const {
-    return CountableEarlyExitBlocks;
+    return CountableEarlyExitingBlocks;
   }
 
   /// The diagnostics report generated for the analysis.  E.g. why we
@@ -731,7 +731,7 @@ class LoopAccessInfo {
 
   /// Keeps track of all the early exits with known or countable exit-not-taken
   /// counts.
-  SmallVector<BasicBlock *, 4> CountableEarlyExitBlocks;
+  SmallVector<BasicBlock *, 4> CountableEarlyExitingBlocks;
 
   /// Indicator that there are non vectorizable stores to a uniform address.
   bool HasDependenceInvolvingLoopInvariantAddress = false;

llvm/include/llvm/Analysis/ScalarEvolution.h

@@ -917,9 +917,9 @@ class ScalarEvolution {
   }
 
   /// Return all the exiting blocks in with exact exit counts.
-  void getExactExitingBlocks(const Loop *L,
-                             SmallVector<BasicBlock *, 4> *Blocks) {
-    getBackedgeTakenInfo(L).getExactExitingBlocks(L, this, Blocks);
+  void getCountableExitingBlocks(const Loop *L,
+                                 SmallVector<BasicBlock *, 4> *Blocks) {
+    getBackedgeTakenInfo(L).getCountableExitingBlocks(L, this, Blocks);
   }
 
   /// Return true if the backedge taken count is either the value returned by
@@ -1562,8 +1562,8 @@ class ScalarEvolution {
                          ScalarEvolution *SE) const;
 
     /// Return all the exiting blocks in with exact exit counts.
-    void getExactExitingBlocks(const Loop *L, ScalarEvolution *SE,
-                               SmallVector<BasicBlock *, 4> *Blocks) const;
+    void getCountableExitingBlocks(const Loop *L, ScalarEvolution *SE,
+                                   SmallVector<BasicBlock *, 4> *Blocks) const;
 
     /// Get the constant max backedge taken count for the loop.
     const SCEV *getConstantMax(ScalarEvolution *SE) const;

llvm/include/llvm/Support/GenericLoopInfo.h

@@ -294,8 +294,8 @@ template <class BlockT, class LoopT> class LoopBase {
   /// Otherwise return null.
   BlockT *getUniqueExitBlock() const;
 
-  /// Return the exit block for the latch if one exists. This function assumes
-  /// the loop has a latch.
+  /// Return the exit block for the latch. This function assumes the loop has a
+  /// single latch.
   BlockT *getLatchExitBlock() const;
 
   /// Return true if this loop does not have any exit blocks.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

@@ -2419,25 +2419,19 @@ bool LoopAccessInfo::isAnalyzableEarlyExitLoop() {
   if (ExitingBlocks.size() < 2)
     return false;
 
-  SmallVector<BasicBlock *, 4> ExactExitingBlocks;
-  PSE->getSE()->getExactExitingBlocks(TheLoop, &ExactExitingBlocks);
+  SmallVector<BasicBlock *, 4> CountableExitingBBs;
+  PSE->getSE()->getCountableExitingBlocks(TheLoop, &CountableExitingBBs);
 
   // We only support one speculative early exit.
-  if ((ExitingBlocks.size() - ExactExitingBlocks.size()) > 1)
+  if ((ExitingBlocks.size() - CountableExitingBBs.size()) > 1)
     return false;
 
   // There could be multiple exiting blocks with an exact exit-not-taken
   // count. Find the speculative early exit block, i.e. the one with an
   // unknown count.
   BasicBlock *TmpBB = nullptr;
   for (BasicBlock *BB1 : ExitingBlocks) {
-    bool Found = false;
-    for (BasicBlock *BB2 : ExactExitingBlocks)
-      if (BB1 == BB2) {
-        Found = true;
-        break;
-      }
-    if (!Found) {
+    if (!is_contained(CountableExitingBBs, BB1)) {
       TmpBB = BB1;
       break;
     }
@@ -2468,7 +2462,7 @@ bool LoopAccessInfo::isAnalyzableEarlyExitLoop() {
     }
   assert(SpeculativeEarlyExitBB &&
          "Expected to find speculative early exit block");
-  CountableEarlyExitBlocks = std::move(ExactExitingBlocks);
+  CountableEarlyExitingBlocks = std::move(CountableExitingBBs);
 
   return true;
 }
@@ -2626,9 +2620,11 @@ void LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
       if (I.mayWriteToMemory()) {
         auto *St = dyn_cast<StoreInst>(&I);
         if (SpeculativeEarlyExitingBB) {
-          recordAnalysis("CantVectorizeInstruction", St)
-              << "cannot vectorize stores in early exit loop";
-          LLVM_DEBUG(dbgs() << "LAA: Found a store in early exit loop.\n");
+          recordAnalysis("CantVectorizeInstruction", &I)
+              << "cannot vectorize instructions that write to memory in early "
+              << "exit loop";
+          LLVM_DEBUG(dbgs() << "LAA: Found an instruction that writes to "
+                            << "memory in early exit loop.\n");
           HasComplexWorkInEarlyExitLoop = true;
           continue;
         }
@@ -2784,7 +2780,6 @@ void LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
   Accesses.buildDependenceSets();
 
   if (SpeculativeEarlyExitingBB) {
-    assert(!Stores.size() && "Did not expect stores in an early exit loop!");
     LoopMayFault = Accesses.mayFault();
     CanVecMem = true;
     return;

llvm/lib/Analysis/ScalarEvolution.cpp

@@ -8602,7 +8602,7 @@ ScalarEvolution::BackedgeTakenInfo::getExact(const Loop *L, ScalarEvolution *SE,
   return SE->getUMinFromMismatchedTypes(Ops, /* Sequential */ true);
 }
 
-void ScalarEvolution::BackedgeTakenInfo::getExactExitingBlocks(
+void ScalarEvolution::BackedgeTakenInfo::getCountableExitingBlocks(
     const Loop *L, ScalarEvolution *SE,
     SmallVector<BasicBlock *, 4> *Blocks) const {
   // All exiting blocks we have collected must dominate the only backedge.
@@ -8625,10 +8625,7 @@ const SCEV *ScalarEvolution::BackedgeTakenInfo::getSpeculative(
     SmallVector<const SCEVPredicate *, 4> *Preds) const {
   // All exiting blocks we have collected must dominate the only backedge.
   const BasicBlock *Latch = L->getLoopLatch();
-  if (!Latch)
-    return SE->getCouldNotCompute();
-
-  if (!hasAnyInfo())
+  if (!Latch || !hasAnyInfo())
     return SE->getCouldNotCompute();
 
   // All exiting blocks we have gathered dominate loop's latch, so speculative

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -2962,7 +2962,7 @@ class VPRegionBlock : public VPBlockBase {
   /// VPRegionBlock.
   VPBlockBase *Exiting;
 
-  /// Hold the Early Exiting block of the SEME region, if one exists.
+  /// Hold the Early Exit block of the SEME region, if one exists.
   VPBlockBase *EarlyExit;
 
   /// We need to keep track of the early exit block from the original scalar

llvm/test/Transforms/LoopVectorize/control-flow.ll

@@ -10,7 +10,7 @@
 ;   return 0;
 ; }
 
-; CHECK: remark: source.cpp:8:7: loop not vectorized: cannot vectorize stores in early exit loop
+; CHECK: remark: source.cpp:8:7: loop not vectorized: cannot vectorize instructions that write to memory in early exit loop
 ; CHECK: remark: source.cpp:5:9: loop not vectorized
 
 ; CHECK: _Z4testPii