[NFC][SCEV] Take out getPredecessorWithUniqueSuccessorForBB to Analysis/CFG.h

llvm/include/llvm/Analysis/CFG.h

for (NodeT Succ : make_range(GT::child_begin(Node), GT::child_end(Node))) {
       // have an irreducible graph.
       if (!isProperBackedge(Node, Succ))
         return true;
     }
   }
 
   return false;
 }
+
+/// Return a predecessor of BB (which may not be an immediate predecessor)
+/// which has exactly one successor from which BB is reachable, or null if
+/// no such block is found.
+std::pair<const BasicBlock *, const BasicBlock *>
+getPredecessorWithUniqueSuccessorForBB(const BasicBlock *BB,
+                                       const LoopInfo &LI);
 } // End llvm namespace
 
 #endif

llvm/lib/Analysis/CFG.cpp

if (A->getParent() == B->getParent()) {
 
     return isPotentiallyReachableFromMany(Worklist, B->getParent(),
                                           ExclusionSet, DT, LI);
   }
 
   return isPotentiallyReachable(
       A->getParent(), B->getParent(), ExclusionSet, DT, LI);
 }
+
+std::pair<const BasicBlock *, const BasicBlock *>
+llvm::getPredecessorWithUniqueSuccessorForBB(const BasicBlock *BB,
+                                             const LoopInfo &LI) {
+  // If the block has a unique predecessor, then there is no path from the
+  // predecessor to the block that does not go through the direct edge
+  // from the predecessor to the block.
+  if (const BasicBlock *Pred = BB->getSinglePredecessor())
+    return {Pred, BB};
+
+  // A loop's header is defined to be a block that dominates the loop.
+  // If the header has a unique predecessor outside the loop, it must be
+  // a block that has exactly one successor that can reach the loop.
+  if (const Loop *L = LI.getLoopFor(BB))
+    return {L->getLoopPredecessor(), L->getHeader()};
+
+  return {nullptr, nullptr};
+}

llvm/lib/Analysis/ScalarEvolution.cpp

 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Argument.h"
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
     return getCouldNotCompute();  // Otherwise it will loop infinitely.
   }
 
   // We could implement others, but I really doubt anyone writes loops like
   // this, and if they did, they would already be constant folded.
   return getCouldNotCompute();
 }
 
-std::pair<const BasicBlock *, const BasicBlock *>
-ScalarEvolution::getPredecessorWithUniqueSuccessorForBB(const BasicBlock *BB)
-    const {
-  // If the block has a unique predecessor, then there is no path from the
-  // predecessor to the block that does not go through the direct edge
-  // from the predecessor to the block.
-  if (const BasicBlock *Pred = BB->getSinglePredecessor())
-    return {Pred, BB};
-
-  // A loop's header is defined to be a block that dominates the loop.
-  // If the header has a unique predecessor outside the loop, it must be
-  // a block that has exactly one successor that can reach the loop.
-  if (const Loop *L = LI.getLoopFor(BB))
-    return {L->getLoopPredecessor(), L->getHeader()};
-
-  return {nullptr, nullptr};
-}
-
 /// SCEV structural equivalence is usually sufficient for testing whether two
 /// expressions are equal, however for the purposes of looking for a condition
 /// guarding a loop, it can be useful to be a little more general, since a
 /// front-end may have replicated the controlling expression.
 static bool HasSameValue(const SCEV *A, const SCEV *B) {
   // Quick check to see if they are the same SCEV.
   if (A == B) return true;
 
bool ScalarEvolution::isBasicBlockEntryGuardedByCond(const BasicBlock *BB,
   // leading to the original block.
   const Loop *ContainingLoop = LI.getLoopFor(BB);
   const BasicBlock *PredBB;
   if (ContainingLoop && ContainingLoop->getHeader() == BB)
     PredBB = ContainingLoop->getLoopPredecessor();
   else
     PredBB = BB->getSinglePredecessor();
   for (std::pair<const BasicBlock *, const BasicBlock *> Pair(PredBB, BB);
-       Pair.first; Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first)) {
+       Pair.first;
+       Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first, LI)) {
     const BranchInst *BlockEntryPredicate =
         dyn_cast<BranchInst>(Pair.first->getTerminator());
     if (!BlockEntryPredicate || BlockEntryPredicate->isUnconditional())
       continue;
 
     if (ProveViaCond(BlockEntryPredicate->getCondition(),
                      BlockEntryPredicate->getSuccessor(0) != Pair.second))
       return true;
const SCEV *ScalarEvolution::applyLoopGuards(const SCEV *Expr, const Loop *L) {
 
   // Third, collect conditions from dominating branches. Starting at the loop
   // predecessor, climb up the predecessor chain, as long as there are
   // predecessors that can be found that have unique successors leading to the
   // original header.
   // TODO: share this logic with isLoopEntryGuardedByCond.
   for (std::pair<const BasicBlock *, const BasicBlock *> Pair(
            L->getLoopPredecessor(), Header);
-       Pair.first; Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first)) {
+       Pair.first;
+       Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first, LI)) {
 
     const BranchInst *LoopEntryPredicate =
         dyn_cast<BranchInst>(Pair.first->getTerminator());
     if (!LoopEntryPredicate || LoopEntryPredicate->isUnconditional())
       continue;
 
     Terms.emplace_back(LoopEntryPredicate->getCondition(),
                        LoopEntryPredicate->getSuccessor(0) == Pair.second);