5 files changed, 29 insertions, 21 deletions

diff --git a/llvm/lib/Analysis/BranchProbabilityInfo.cpp b/llvm/lib/Analysis/BranchProbabilityInfo.cpp
index fa9df4c8edb..bbd87505952 100644
--- a/llvm/lib/Analysis/BranchProbabilityInfo.cpp
+++ b/llvm/lib/Analysis/BranchProbabilityInfo.cpp
@@ -528,9 +528,13 @@ void BranchProbabilityInfo::print(raw_ostream &OS, const Module *) const {
   // We print the probabilities from the last function the analysis ran over,
   // or the function it is currently running over.
   assert(LastF && "Cannot print prior to running over a function");
-  for (const BasicBlock &BB : *LastF)
-    for (const BasicBlock *Succ : successors(&BB))
-      printEdgeProbability(OS << "  ", &BB, Succ);
+  for (Function::const_iterator BI = LastF->begin(), BE = LastF->end();
+       BI != BE; ++BI) {
+    for (succ_const_iterator SI = succ_begin(BI), SE = succ_end(BI);
+         SI != SE; ++SI) {
+      printEdgeProbability(OS << "  ", BI, *SI);
+    }
+  }
 }
 
 uint32_t BranchProbabilityInfo::getSumForBlock(const BasicBlock *BB) const {
@@ -559,7 +563,8 @@ BasicBlock *BranchProbabilityInfo::getHotSucc(BasicBlock *BB) const {
   uint32_t MaxWeight = 0;
   BasicBlock *MaxSucc = nullptr;
 
-  for (BasicBlock *Succ : successors(BB)) {
+  for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
+    BasicBlock *Succ = *I;
     uint32_t Weight = getEdgeWeight(BB, Succ);
     uint32_t PrevSum = Sum;
 
diff --git a/llvm/lib/Analysis/Interval.cpp b/llvm/lib/Analysis/Interval.cpp
index ca71cf38628..e3e785ffc45 100644
--- a/llvm/lib/Analysis/Interval.cpp
+++ b/llvm/lib/Analysis/Interval.cpp
@@ -29,8 +29,9 @@ using namespace llvm;
 bool Interval::isLoop() const {
   // There is a loop in this interval iff one of the predecessors of the header
   // node lives in the interval.
-  for (BasicBlock *Pred : predecessors(HeaderNode))
-    if (contains(Pred))
+  for (::pred_iterator I = ::pred_begin(HeaderNode), E = ::pred_end(HeaderNode);
+       I != E; ++I)
+    if (contains(*I))
       return true;
   return false;
 }
diff --git a/llvm/lib/Analysis/LazyValueInfo.cpp b/llvm/lib/Analysis/LazyValueInfo.cpp
index a65480c2e40..9f919f7644a 100644
--- a/llvm/lib/Analysis/LazyValueInfo.cpp
+++ b/llvm/lib/Analysis/LazyValueInfo.cpp
@@ -625,9 +625,9 @@ bool LazyValueInfoCache::solveBlockValueNonLocal(LVILatticeVal &BBLV,
   // Loop over all of our predecessors, merging what we know from them into
   // result.
   bool EdgesMissing = false;
-  for (BasicBlock *Pred : predecessors(BB)) {
+  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
     LVILatticeVal EdgeResult;
-    EdgesMissing |= !getEdgeValue(Val, Pred, BB, EdgeResult);
+    EdgesMissing |= !getEdgeValue(Val, *PI, BB, EdgeResult);
     if (EdgesMissing)
       continue;
 
diff --git a/llvm/lib/Analysis/LoopInfo.cpp b/llvm/lib/Analysis/LoopInfo.cpp
index a6d8b55c08f..46c0eaabe1a 100644
--- a/llvm/lib/Analysis/LoopInfo.cpp
+++ b/llvm/lib/Analysis/LoopInfo.cpp
@@ -336,8 +336,9 @@ bool Loop::hasDedicatedExits() const {
   SmallVector<BasicBlock *, 4> ExitBlocks;
   getExitBlocks(ExitBlocks);
   for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
-    for (BasicBlock *Pred : predecessors(ExitBlocks[i]))
-      if (!contains(Pred))
+    for (pred_iterator PI = pred_begin(ExitBlocks[i]),
+         PE = pred_end(ExitBlocks[i]); PI != PE; ++PI)
+      if (!contains(*PI))
         return false;
   // All the requirements are met.
   return true;
@@ -359,12 +360,12 @@ Loop::getUniqueExitBlocks(SmallVectorImpl<BasicBlock *> &ExitBlocks) const {
     BasicBlock *current = *BI;
     switchExitBlocks.clear();
 
-    for (BasicBlock *Succ : successors(*BI)) {
+    for (succ_iterator I = succ_begin(*BI), E = succ_end(*BI); I != E; ++I) {
       // If block is inside the loop then it is not a exit block.
-      if (contains(Succ))
+      if (contains(*I))
         continue;
 
-      pred_iterator PI = pred_begin(Succ);
+      pred_iterator PI = pred_begin(*I);
       BasicBlock *firstPred = *PI;
 
       // If current basic block is this exit block's first predecessor
@@ -378,17 +379,17 @@ Loop::getUniqueExitBlocks(SmallVectorImpl<BasicBlock *> &ExitBlocks) const {
       // then it is possible that there are multiple edges from current block
       // to one exit block.
       if (std::distance(succ_begin(current), succ_end(current)) <= 2) {
-        ExitBlocks.push_back(Succ);
+        ExitBlocks.push_back(*I);
         continue;
       }
 
       // In case of multiple edges from current block to exit block, collect
       // only one edge in ExitBlocks. Use switchExitBlocks to keep track of
       // duplicate edges.
-      if (std::find(switchExitBlocks.begin(), switchExitBlocks.end(), Succ)
+      if (std::find(switchExitBlocks.begin(), switchExitBlocks.end(), *I)
           == switchExitBlocks.end()) {
-        switchExitBlocks.push_back(Succ);
-        ExitBlocks.push_back(Succ);
+        switchExitBlocks.push_back(*I);
+        ExitBlocks.push_back(*I);
       }
     }
   }
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index fd5b86b4634..06dbde58c10 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -4512,12 +4512,13 @@ ScalarEvolution::ComputeExitLimit(const Loop *L, BasicBlock *ExitingBlock) {
   // lead to the loop header.
   bool MustExecuteLoopHeader = true;
   BasicBlock *Exit = nullptr;
-  for (BasicBlock *Succ : successors(ExitingBlock))
-    if (!L->contains(Succ)) {
+  for (succ_iterator SI = succ_begin(ExitingBlock), SE = succ_end(ExitingBlock);
+       SI != SE; ++SI)
+    if (!L->contains(*SI)) {
       if (Exit) // Multiple exit successors.
         return getCouldNotCompute();
-      Exit = Succ;
-    } else if (Succ != L->getHeader()) {
+      Exit = *SI;
+    } else if (*SI != L->getHeader()) {
       MustExecuteLoopHeader = false;
     }