[C++11] Add predecessors(BasicBlock *) / successors(BasicBlock *) iterator ranges.

[mjacob]

Summary

This patch introduces two new iterator ranges and updates existing code to use it. No functional change intended.

[mjacob]

Update patch to make it apply cleanly to HEAD.

[dblaikie]

Generally looks good - some optional comments, but they're potentially orthogonal/follow-up work.

lib/Analysis/BranchProbabilityInfo.cpp

533–534

You could drop the {} from this loop (and the outer loop, actually... ), but I don't think it's necessary in this cleanup (and may even be better as a separate commit anyway)

533–534

I think we've been pretty forward about using "auto" more aggressively - especially in "obvious" cases, which I think this qualifies (BI might one day be "BB" when that outer loop is changed to a range-based-for, but either name connotes "basic block" pretty pervasively in LLVM - and iterating over the predecessors or successors of a basic block clearly consists of more basic blocks).

So maybe these should be "auto *" and "const auto *" throughout the refactoring.

[mjacob]

lib/Analysis/BranchProbabilityInfo.cpp

533–534

Yes, I'll do these changes (rangify outer loop, remove braces) after committing this one.

I'm not sure if it's better to use "auto" here -- it doesn't increase readability. I don't think "BasicBlock" is a very cumbersome name. "Succ" is a general name that could also mean "successor instruction" for example.

[dblaikie]

LGTM

(In follow up many of these could be std::one_of, std::any_of, none_of, etc - though we could add llvm versions of those that work on ranges directly (rather than iterator begin/end))

docs/ProgrammersManual.rst

 routines defined in ``"llvm/Support/CFG.h"``.  Just use code like this to
 iterate over all predecessors of BB:
 
 .. code-block:: c++
 
   #include "llvm/Support/CFG.h"
   BasicBlock *BB = ...;
 
-  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-    BasicBlock *Pred = *PI;
+  for (BasicBlock *Pred : predecessors(BB)) {
     // ...
   }
 
-Similarly, to iterate over successors use ``succ_iterator/succ_begin/succ_end``.
+Similarly, to iterate over successors use ``successors``.
 
 .. _simplechanges:
 
 Making simple changes
 ---------------------
 
 There are some primitive transformation operations present in the LLVM
 infrastructure that are worth knowing about.  When performing transformations,

include/llvm/IR/CFG.h

 inline pred_iterator pred_begin(BasicBlock *BB) { return pred_iterator(BB); }
 inline const_pred_iterator pred_begin(const BasicBlock *BB) {
   return const_pred_iterator(BB);
 }
 inline pred_iterator pred_end(BasicBlock *BB) { return pred_iterator(BB, true);}
 inline const_pred_iterator pred_end(const BasicBlock *BB) {
   return const_pred_iterator(BB, true);
 }
+inline iterator_range<pred_iterator> predecessors(BasicBlock *BB) {
+  return make_range(pred_begin(BB), pred_end(BB));
+}
+inline iterator_range<const_pred_iterator> predecessors(const BasicBlock *BB) {
+  return make_range(pred_begin(BB), pred_end(BB));
+}
 
 
 
 //===----------------------------------------------------------------------===//
 // BasicBlock succ_iterator definition
 //===----------------------------------------------------------------------===//
 
 template <class Term_, class BB_>           // Successor Iterator
inline succ_const_iterator succ_begin(const BasicBlock *BB) {
   return succ_const_iterator(BB->getTerminator());
 }
 inline succ_iterator succ_end(BasicBlock *BB) {
   return succ_iterator(BB->getTerminator(), true);
 }
 inline succ_const_iterator succ_end(const BasicBlock *BB) {
   return succ_const_iterator(BB->getTerminator(), true);
 }
+inline iterator_range<succ_iterator> successors(BasicBlock *BB) {
+  return make_range(succ_begin(BB), succ_end(BB));
+}
+inline iterator_range<succ_const_iterator> successors(const BasicBlock *BB) {
+  return make_range(succ_begin(BB), succ_end(BB));
+}
 
 template <typename T, typename U> struct isPodLike<SuccIterator<T, U> > {
   static const bool value = isPodLike<T>::value;
 };
 
 
 
 //===--------------------------------------------------------------------===//

lib/Analysis/BranchProbabilityInfo.cpp

 
 void BranchProbabilityInfo::print(raw_ostream &OS, const Module *) const {
   OS << "---- Branch Probabilities ----\n";
   // 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 (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);
+    for (const BasicBlock *Succ : successors(BI)) {
+      printEdgeProbability(OS << "  ", BI, Succ);
     }
   }
 }
 
 uint32_t BranchProbabilityInfo::getSumForBlock(const BasicBlock *BB) const {
   uint32_t Sum = 0;
 
   for (succ_const_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
isEdgeHot(const BasicBlock *Src, const BasicBlock *Dst) const {
   return getEdgeProbability(Src, Dst) > BranchProbability(4, 5);
 }
 
 BasicBlock *BranchProbabilityInfo::getHotSucc(BasicBlock *BB) const {
   uint32_t Sum = 0;
   uint32_t MaxWeight = 0;
   BasicBlock *MaxSucc = nullptr;
 
-  for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
-    BasicBlock *Succ = *I;
+  for (BasicBlock *Succ : successors(BB)) {
     uint32_t Weight = getEdgeWeight(BB, Succ);
     uint32_t PrevSum = Sum;
 
     Sum += Weight;
     assert(Sum > PrevSum); (void) PrevSum;
 
     if (Weight > MaxWeight) {
       MaxWeight = Weight;

lib/Analysis/Interval.cpp

 // Interval Implementation
 //===----------------------------------------------------------------------===//
 
 // isLoop - Find out if there is a back edge in this interval...
 //
 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 (::pred_iterator I = ::pred_begin(HeaderNode), E = ::pred_end(HeaderNode);
-       I != E; ++I)
-    if (contains(*I))
+  for (BasicBlock *Pred : predecessors(HeaderNode))
+    if (contains(Pred))
       return true;
   return false;
 }
 
 
 void Interval::print(raw_ostream &OS) const {
   OS << "-------------------------------------------------------------\n"
        << "Interval Contents:\n";

lib/Analysis/LazyValueInfo.cpp

if (BB == &BB->getParent()->getEntryBlock()) {
     }
     BBLV = Result;
     return true;
   }
 
   // Loop over all of our predecessors, merging what we know from them into
   // result.
   bool EdgesMissing = false;
-  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+  for (BasicBlock *Pred : predecessors(BB)) {
     LVILatticeVal EdgeResult;
-    EdgesMissing |= !getEdgeValue(Val, *PI, BB, EdgeResult);
+    EdgesMissing |= !getEdgeValue(Val, Pred, BB, EdgeResult);
     if (EdgesMissing)
       continue;
 
     Result.mergeIn(EdgeResult);
 
     // If we hit overdefined, exit early.  The BlockVals entry is already set
     // to overdefined.
     if (Result.isOverdefined()) {

lib/Analysis/LoopInfo.cpp

 /// hasDedicatedExits - Return true if no exit block for the loop
 /// has a predecessor that is outside the loop.
 bool Loop::hasDedicatedExits() const {
   // Each predecessor of each exit block of a normal loop is contained
   // within the loop.
   SmallVector<BasicBlock *, 4> ExitBlocks;
   getExitBlocks(ExitBlocks);
   for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
-    for (pred_iterator PI = pred_begin(ExitBlocks[i]),
-         PE = pred_end(ExitBlocks[i]); PI != PE; ++PI)
-      if (!contains(*PI))
+    for (BasicBlock *Pred : predecessors(ExitBlocks[i]))
+      if (!contains(Pred))
         return false;
   // All the requirements are met.
   return true;
 }
 
 /// getUniqueExitBlocks - Return all unique successor blocks of this loop.
 /// These are the blocks _outside of the current loop_ which are branched to.
 /// This assumes that loop exits are in canonical form.
 ///
 void
 Loop::getUniqueExitBlocks(SmallVectorImpl<BasicBlock *> &ExitBlocks) const {
   assert(hasDedicatedExits() &&
          "getUniqueExitBlocks assumes the loop has canonical form exits!");
 
   SmallVector<BasicBlock *, 32> switchExitBlocks;
 
   for (block_iterator BI = block_begin(), BE = block_end(); BI != BE; ++BI) {
 
     BasicBlock *current = *BI;
     switchExitBlocks.clear();
 
-    for (succ_iterator I = succ_begin(*BI), E = succ_end(*BI); I != E; ++I) {
+    for (BasicBlock *Succ : successors(*BI)) {
       // If block is inside the loop then it is not a exit block.
-      if (contains(*I))
+      if (contains(Succ))
         continue;
 
-      pred_iterator PI = pred_begin(*I);
+      pred_iterator PI = pred_begin(Succ);
       BasicBlock *firstPred = *PI;
 
       // If current basic block is this exit block's first predecessor
       // then only insert exit block in to the output ExitBlocks vector.
       // This ensures that same exit block is not inserted twice into
       // ExitBlocks vector.
       if (current != firstPred)
         continue;
 
       // If a terminator has more then two successors, for example SwitchInst,
       // 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(*I);
+        ExitBlocks.push_back(Succ);
         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(), *I)
+      if (std::find(switchExitBlocks.begin(), switchExitBlocks.end(), Succ)
           == switchExitBlocks.end()) {
-        switchExitBlocks.push_back(*I);
-        ExitBlocks.push_back(*I);
+        switchExitBlocks.push_back(Succ);
+        ExitBlocks.push_back(Succ);
       }
     }
   }
 }
 
 /// getUniqueExitBlock - If getUniqueExitBlocks would return exactly one
 /// block, return that block. Otherwise return null.
 BasicBlock *Loop::getUniqueExitBlock() const {

lib/Analysis/RegionInfo.cpp

 
 Loop *Region::outermostLoopInRegion(LoopInfo *LI, BasicBlock* BB) const {
   assert(LI && BB && "LI and BB cannot be null!");
   Loop *L = LI->getLoopFor(BB);
   return outermostLoopInRegion(L);
 }
 
 BasicBlock *Region::getEnteringBlock() const {
-  BasicBlock *entry = getEntry();
-  BasicBlock *Pred;
   BasicBlock *enteringBlock = nullptr;
 
-  for (pred_iterator PI = pred_begin(entry), PE = pred_end(entry); PI != PE;
-       ++PI) {
-    Pred = *PI;
+  for (BasicBlock *Pred : predecessors(getEntry())) {
     if (DT->getNode(Pred) && !contains(Pred)) {
       if (enteringBlock)
         return nullptr;
 
       enteringBlock = Pred;
     }
   }
 
   return enteringBlock;
 }
 
 BasicBlock *Region::getExitingBlock() const {
   BasicBlock *exit = getExit();
-  BasicBlock *Pred;
   BasicBlock *exitingBlock = nullptr;
 
   if (!exit)
     return nullptr;
 
-  for (pred_iterator PI = pred_begin(exit), PE = pred_end(exit); PI != PE;
-       ++PI) {
-    Pred = *PI;
+  for (BasicBlock *Pred : predecessors(exit)) {
     if (contains(Pred)) {
       if (exitingBlock)
         return nullptr;
 
       exitingBlock = Pred;
     }
   }
 

 }
 
 void Region::verifyBBInRegion(BasicBlock *BB) const {
   if (!contains(BB))
     llvm_unreachable("Broken region found!");
 
   BasicBlock *entry = getEntry(), *exit = getExit();
 
-  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
-    if (!contains(*SI) && exit != *SI)
+  for (BasicBlock *Succ : successors(BB))
+    if (!contains(Succ) && exit != Succ)
       llvm_unreachable("Broken region found!");
 
   if (entry != BB)
-    for (pred_iterator SI = pred_begin(BB), SE = pred_end(BB); SI != SE; ++SI)
-      if (!contains(*SI))
+    for (BasicBlock *Pred : predecessors(BB))
+      if (!contains(Pred))
         llvm_unreachable("Broken region found!");
 }
 
 void Region::verifyWalk(BasicBlock *BB, std::set<BasicBlock*> *visited) const {
   BasicBlock *exit = getExit();
 
   visited->insert(BB);
 
   verifyBBInRegion(BB);
 
-  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
-    if (*SI != exit && visited->find(*SI) == visited->end())
-        verifyWalk(*SI, visited);
+  for (BasicBlock *Succ : successors(BB))
+    if (Succ != exit && visited->find(Succ) == visited->end())
+        verifyWalk(Succ, visited);
 }
 
 void Region::verifyRegion() const {
   // Only do verification when user wants to, otherwise this expensive
   // check will be invoked by PassManager.
   if (!VerifyRegionInfo) return;
 
   std::set<BasicBlock*> visited;

 }
 
 Region *Region::getExpandedRegion() const {
   unsigned NumSuccessors = exit->getTerminator()->getNumSuccessors();
 
   if (NumSuccessors == 0)
     return nullptr;
 
-  for (pred_iterator PI = pred_begin(getExit()), PE = pred_end(getExit());
-       PI != PE; ++PI)
-    if (!DT->dominates(getEntry(), *PI))
+  for (BasicBlock *Pred : predecessors(getExit()))
+    if (!DT->dominates(getEntry(), Pred))
       return nullptr;
 
   Region *R = RI->getRegionFor(exit);
 
   if (R->getEntry() != exit) {
     if (exit->getTerminator()->getNumSuccessors() == 1)
       return new Region(getEntry(), *succ_begin(exit), RI, DT);
     else
       return nullptr;
   }
 
   while (R->getParent() && R->getParent()->getEntry() == exit)
     R = R->getParent();
 
   if (!DT->dominates(getEntry(), R->getExit()))
-    for (pred_iterator PI = pred_begin(getExit()), PE = pred_end(getExit());
-         PI != PE; ++PI)
-    if (!DT->dominates(R->getExit(), *PI))
+    for (BasicBlock *Pred : predecessors(getExit()))
+      if (!DT->dominates(R->getExit(), Pred))
         return nullptr;
 
   return new Region(getEntry(), R->getExit(), RI, DT);
 }
 
 void Region::print(raw_ostream &OS, bool print_tree, unsigned level,
                    enum PrintStyle Style) const {
   if (print_tree)
     OS.indent(level*2) << "[" << level << "] " << getNameStr();

 }
 
 //===----------------------------------------------------------------------===//
 // RegionInfo implementation
 //
 
 bool RegionInfo::isCommonDomFrontier(BasicBlock *BB, BasicBlock *entry,
                                      BasicBlock *exit) const {
-  for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI) {
-    BasicBlock *P = *PI;
+  for (BasicBlock *P : predecessors(BB))
     if (DT->dominates(entry, P) && !DT->dominates(exit, P))
       return false;
-  }
   return true;
 }
 
 bool RegionInfo::isRegion(BasicBlock *entry, BasicBlock *exit) const {
   assert(entry && exit && "entry and exit must not be null!");
   typedef DominanceFrontier::DomSetType DST;
 
   DST *entrySuccs = &DF->find(entry)->second;
else // No single exit exists.
       return Exit;
 
     // Get largest region that starts at Exit.
     Region *ExitR = getRegionFor(Exit);
     while (ExitR && ExitR->getParent()
            && ExitR->getParent()->getEntry() == Exit)
       ExitR = ExitR->getParent();
 
-    for (pred_iterator PI = pred_begin(Exit), PE = pred_end(Exit); PI != PE;
-         ++PI)
-      if (!R->contains(*PI) && !ExitR->contains(*PI))
+    for (BasicBlock *Pred : predecessors(Exit))
+      if (!R->contains(Pred) && !ExitR->contains(Pred))
         break;
 
     // This stops infinite cycles.
     if (DT->dominates(Exit, BB))
       break;
 
     BB = Exit;
   }

lib/Analysis/ScalarEvolution.cpp

 ScalarEvolution::ExitLimit
 ScalarEvolution::ComputeExitLimit(const Loop *L, BasicBlock *ExitingBlock) {
 
   // Okay, we've chosen an exiting block.  See what condition causes us to
   // exit at this block and remember the exit block and whether all other targets
   // lead to the loop header.
   bool MustExecuteLoopHeader = true;
   BasicBlock *Exit = nullptr;
-  for (succ_iterator SI = succ_begin(ExitingBlock), SE = succ_end(ExitingBlock);
-       SI != SE; ++SI)
-    if (!L->contains(*SI)) {
+  for (BasicBlock *Succ : successors(ExitingBlock))
+    if (!L->contains(Succ)) {
       if (Exit) // Multiple exit successors.
         return getCouldNotCompute();
-      Exit = *SI;
-    } else if (*SI != L->getHeader()) {
+      Exit = Succ;
+    } else if (Succ != L->getHeader()) {
       MustExecuteLoopHeader = false;
     }
 
   // At this point, we know we have a conditional branch that determines whether
   // the loop is exited.  However, we don't know if the branch is executed each
   // time through the loop.  If not, then the execution count of the branch will
   // not be equal to the trip count of the loop.
   //

lib/CodeGen/CodeGenPrepare.cpp

if (InValPhi && InValPhi->getParent() == BB) {
                         InValPhi->getIncomingBlock(i));
     } else {
       // Otherwise, add one instance of the dominating value for each edge that
       // we will be adding.
       if (PHINode *BBPN = dyn_cast<PHINode>(BB->begin())) {
         for (unsigned i = 0, e = BBPN->getNumIncomingValues(); i != e; ++i)
           PN->addIncoming(InVal, BBPN->getIncomingBlock(i));
       } else {
-        for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
-          PN->addIncoming(InVal, *PI);
+        for (BasicBlock *Pred : predecessors(BB))
+          PN->addIncoming(InVal, Pred);
       }
     }
   }
 
   // The PHIs are now updated, change everything that refers to BB to use
   // DestBB and remove BB.
   BB->replaceAllUsesWith(DestBB);
   if (DT && !ModifiedDT) {
for (unsigned I = 0, E = PN->getNumIncomingValues(); I != E; ++I) {
       CallInst *CI = dyn_cast<CallInst>(PN->getIncomingValue(I));
       // Make sure the phi value is indeed produced by the tail call.
       if (CI && CI->hasOneUse() && CI->getParent() == PN->getIncomingBlock(I) &&
           TLI->mayBeEmittedAsTailCall(CI))
         TailCalls.push_back(CI);
     }
   } else {
     SmallPtrSet<BasicBlock*, 4> VisitedBBs;
-    for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI) {
-      if (!VisitedBBs.insert(*PI))
+    for (BasicBlock *Pred : predecessors(BB)) {
+      if (!VisitedBBs.insert(Pred))
         continue;
 
-      BasicBlock::InstListType &InstList = (*PI)->getInstList();
+      BasicBlock::InstListType &InstList = Pred->getInstList();
       BasicBlock::InstListType::reverse_iterator RI = InstList.rbegin();
       BasicBlock::InstListType::reverse_iterator RE = InstList.rend();
       do { ++RI; } while (RI != RE && isa<DbgInfoIntrinsic>(&*RI));
       if (RI == RE)
         continue;
 
       CallInst *CI = dyn_cast<CallInst>(&*RI);
       if (CI && CI->use_empty() && TLI->mayBeEmittedAsTailCall(CI))

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
   // Iterate over all basic blocks in the function.
   ReversePostOrderTraversal<const Function*> RPOT(&Fn);
   for (ReversePostOrderTraversal<const Function*>::rpo_iterator
        I = RPOT.begin(), E = RPOT.end(); I != E; ++I) {
     const BasicBlock *LLVMBB = *I;
 
     if (OptLevel != CodeGenOpt::None) {
       bool AllPredsVisited = true;
-      for (const_pred_iterator PI = pred_begin(LLVMBB), PE = pred_end(LLVMBB);
-           PI != PE; ++PI) {
-        if (!FuncInfo->VisitedBBs.count(*PI)) {
+      for (const BasicBlock *Pred : predecessors(LLVMBB)) {
+        if (!FuncInfo->VisitedBBs.count(Pred)) {
           AllPredsVisited = false;
           break;
         }
       }
 
       if (AllPredsVisited) {
         for (BasicBlock::const_iterator I = LLVMBB->begin();
              const PHINode *PN = dyn_cast<PHINode>(I); ++I)

lib/CodeGen/SjLjEHPrepare.cpp

 
 /// MarkBlocksLiveIn - Insert BB and all of its predescessors into LiveBBs until
 /// we reach blocks we've already seen.
 static void MarkBlocksLiveIn(BasicBlock *BB,
                              SmallPtrSet<BasicBlock *, 64> &LiveBBs) {
   if (!LiveBBs.insert(BB))
     return; // already been here.
 
-  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
-    MarkBlocksLiveIn(*PI, LiveBBs);
+  for (BasicBlock *Pred : predecessors(BB))
+    MarkBlocksLiveIn(Pred, LiveBBs);
 }
 
 /// substituteLPadValues - Substitute the values returned by the landingpad
 /// instruction with those returned by the personality function.
 void SjLjEHPrepare::substituteLPadValues(LandingPadInst *LPI, Value *ExnVal,
                                          Value *SelVal) {
   SmallVector<Value *, 8> UseWorkList(LPI->user_begin(), LPI->user_end());
   while (!UseWorkList.empty()) {

lib/CodeGen/UnreachableBlockElim.cpp

bool UnreachableBlockElim::runOnFunction(Function &F) {
   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
     if (!Reachable.count(I)) {
       BasicBlock *BB = I;
       DeadBlocks.push_back(BB);
       while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) {
         PN->replaceAllUsesWith(Constant::getNullValue(PN->getType()));
         BB->getInstList().pop_front();
       }
-      for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
-        (*SI)->removePredecessor(BB);
+      for (BasicBlock *S : successors(BB))
+        S->removePredecessor(BB);
       BB->dropAllReferences();
     }
 
   // Actually remove the blocks now.
   for (unsigned i = 0, e = DeadBlocks.size(); i != e; ++i) {
     DeadBlocks[i]->eraseFromParent();
   }
 

lib/IR/BasicBlock.cpp

BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName) {
   // Add a branch instruction to the newly formed basic block.
   BranchInst::Create(New, this);
 
   // Now we must loop through all of the successors of the New block (which
   // _were_ the successors of the 'this' block), and update any PHI nodes in
   // successors.  If there were PHI nodes in the successors, then they need to
   // know that incoming branches will be from New, not from Old.
   //
-  for (succ_iterator I = succ_begin(New), E = succ_end(New); I != E; ++I) {
+  for (BasicBlock *Successor : successors(New)) {
     // Loop over any phi nodes in the basic block, updating the BB field of
     // incoming values...
-    BasicBlock *Successor = *I;
     PHINode *PN;
     for (BasicBlock::iterator II = Successor->begin();
          (PN = dyn_cast<PHINode>(II)); ++II) {
       int IDX = PN->getBasicBlockIndex(this);
       while (IDX != -1) {
         PN->setIncomingBlock((unsigned)IDX, New);
         IDX = PN->getBasicBlockIndex(this);
       }

lib/IR/Dominators.cpp

bool DominatorTree::dominates(const BasicBlockEdge &BBE,
   //      .      NormalDest
   //      .
   //
   // Given the definition of dominance, NormalDest is dominated by X iff X
   // dominates all of NormalDest's predecessors (X, B, C in the example). X
   // trivially dominates itself, so we only have to find if it dominates the
   // other predecessors. Since the only way out of X is via NormalDest, X can
   // only properly dominate a node if NormalDest dominates that node too.
-  for (const_pred_iterator PI = pred_begin(End), E = pred_end(End);
-       PI != E; ++PI) {
-    const BasicBlock *BB = *PI;
+  for (const BasicBlock *BB : predecessors(End)) {
     if (BB == Start)
       continue;
 
     if (!dominates(End, BB))
       return false;
   }
   return true;
 }

lib/IR/Verifier.cpp

void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
 
   // The landingpad instruction is ill-formed if it doesn't have any clauses and
   // isn't a cleanup.
   Assert1(LPI.getNumClauses() > 0 || LPI.isCleanup(),
           "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
 
   // The landingpad instruction defines its parent as a landing pad block. The
   // landing pad block may be branched to only by the unwind edge of an invoke.
-  for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
-    const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator());
+  for (BasicBlock *Pred : predecessors(BB)) {
+    const InvokeInst *II = dyn_cast<InvokeInst>(Pred->getTerminator());
     Assert1(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
             "Block containing LandingPadInst must be jumped to "
             "only by the unwind edge of an invoke.", &LPI);
   }
 
   // The landingpad instruction must be the first non-PHI instruction in the
   // block.
   Assert1(LPI.getParent()->getLandingPadInst() == &LPI,

lib/Transforms/IPO/ArgumentPromotion.cpp

for (unsigned i = 0, e = Loads.size(); i != e; ++i) {
 
     AliasAnalysis::Location Loc = AA.getLocation(Load);
     if (AA.canInstructionRangeModify(BB->front(), *Load, Loc))
       return false;  // Pointer is invalidated!
 
     // Now check every path from the entry block to the load for transparency.
     // To do this, we perform a depth first search on the inverse CFG from the
     // loading block.
-    for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-      BasicBlock *P = *PI;
+    for (BasicBlock *P : predecessors(BB)) {
       for (idf_ext_iterator<BasicBlock*, SmallPtrSet<BasicBlock*, 16> >
              I = idf_ext_begin(P, TranspBlocks),
              E = idf_ext_end(P, TranspBlocks); I != E; ++I)
         if (AA.canBasicBlockModify(**I, Loc))
           return false;
     }
   }
 

lib/Transforms/IPO/LoopExtractor.cpp

for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
     InvokeInst *II = dyn_cast<InvokeInst>(I);
     if (!II) continue;
     BasicBlock *Parent = II->getParent();
     BasicBlock *LPad = II->getUnwindDest();
 
     // Look through the landing pad's predecessors. If one of them ends in an
     // 'invoke', then we want to split the landing pad.
     bool Split = false;
-    for (pred_iterator
-           PI = pred_begin(LPad), PE = pred_end(LPad); PI != PE; ++PI) {
-      BasicBlock *BB = *PI;
+    for (BasicBlock *BB : predecessors(LPad)) {
       if (BB->isLandingPad() && BB != Parent &&
           isa<InvokeInst>(Parent->getTerminator())) {
         Split = true;
         break;
       }
     }
 
     if (!Split) continue;

lib/Transforms/IPO/PartialInlining.cpp

Function* PartialInliner::unswitchFunction(Function* F) {
   BasicBlock* entryBlock = F->begin();
   BranchInst *BR = dyn_cast<BranchInst>(entryBlock->getTerminator());
   if (!BR || BR->isUnconditional())
     return nullptr;
   
   BasicBlock* returnBlock = nullptr;
   BasicBlock* nonReturnBlock = nullptr;
   unsigned returnCount = 0;
-  for (succ_iterator SI = succ_begin(entryBlock), SE = succ_end(entryBlock);
-       SI != SE; ++SI)
-    if (isa<ReturnInst>((*SI)->getTerminator())) {
-      returnBlock = *SI;
+  for (BasicBlock *Succ : successors(entryBlock))
+    if (isa<ReturnInst>(Succ->getTerminator())) {
+      returnBlock = Succ;
       returnCount++;
     } else
-      nonReturnBlock = *SI;
+      nonReturnBlock = Succ;
   
   if (returnCount != 1)
     return nullptr;
   
   // Clone the function, so that we can hack away on it.
   ValueToValueMapTy VMap;
   Function* duplicateFunction = CloneFunction(F, VMap,
                                               /*ModuleLevelChanges=*/false);

lib/Transforms/InstCombine/InstructionCombining.cpp

if (I->hasOneUse()) {
       if (PHINode *PN = dyn_cast<PHINode>(UserInst))
         UserParent = PN->getIncomingBlock(*I->use_begin());
       else
         UserParent = UserInst->getParent();
 
       if (UserParent != BB) {
         bool UserIsSuccessor = false;
         // See if the user is one of our successors.
-        for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
-          if (*SI == UserParent) {
+        for (BasicBlock *Succ : successors(BB))
+          if (Succ == UserParent) {
             UserIsSuccessor = true;
             break;
           }
 
         // If the user is one of our immediate successors, and if that successor
         // only has us as a predecessors (we'd have to split the critical edge
         // otherwise), we can keep going.
         if (UserIsSuccessor && UserParent->getSinglePredecessor()) {

lib/Transforms/Scalar/DeadStoreElimination.cpp

bool DSE::runOnBasicBlock(BasicBlock &BB) {
 
   return MadeChange;
 }
 
 /// Find all blocks that will unconditionally lead to the block BB and append
 /// them to F.
 static void FindUnconditionalPreds(SmallVectorImpl<BasicBlock *> &Blocks,
                                    BasicBlock *BB, DominatorTree *DT) {
-  for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
-    BasicBlock *Pred = *I;
+  for (BasicBlock *Pred : predecessors(BB)) {
     if (Pred == BB) continue;
     TerminatorInst *PredTI = Pred->getTerminator();
     if (PredTI->getNumSuccessors() != 1)
       continue;
 
     if (DT->isReachableFromEntry(Pred))
       Blocks.push_back(Pred);
   }

lib/Transforms/Scalar/GVN.cpp

bool GVN::PerformLoadPRE(LoadInst *LI, AvailValInBlkVect &ValuesPerBlock,
   MapVector<BasicBlock *, Value *> PredLoads;
   DenseMap<BasicBlock*, char> FullyAvailableBlocks;
   for (unsigned i = 0, e = ValuesPerBlock.size(); i != e; ++i)
     FullyAvailableBlocks[ValuesPerBlock[i].BB] = true;
   for (unsigned i = 0, e = UnavailableBlocks.size(); i != e; ++i)
     FullyAvailableBlocks[UnavailableBlocks[i]] = false;
 
   SmallVector<BasicBlock *, 4> CriticalEdgePred;
-  for (pred_iterator PI = pred_begin(LoadBB), E = pred_end(LoadBB);
-       PI != E; ++PI) {
-    BasicBlock *Pred = *PI;
+  for (BasicBlock *Pred : predecessors(LoadBB)) {
     if (IsValueFullyAvailableInBlock(Pred, FullyAvailableBlocks, 0)) {
       continue;
     }
 
     if (Pred->getTerminator()->getNumSuccessors() != 1) {
       if (isa<IndirectBrInst>(Pred->getTerminator())) {
         DEBUG(dbgs() << "COULD NOT PRE LOAD BECAUSE OF INDBR CRITICAL EDGE '"
               << Pred->getName() << "': " << *LI << '\n');
for (BasicBlock::iterator BI = CurrentBlock->begin(),
       // but not the other.  We also explicitly disallow cases
       // where the successor is its own predecessor, because they're
       // more complicated to get right.
       unsigned NumWith = 0;
       unsigned NumWithout = 0;
       BasicBlock *PREPred = nullptr;
       predMap.clear();
 
-      for (pred_iterator PI = pred_begin(CurrentBlock),
-           PE = pred_end(CurrentBlock); PI != PE; ++PI) {
-        BasicBlock *P = *PI;
+      for (BasicBlock *P : predecessors(CurrentBlock)) {
         // We're not interested in PRE where the block is its
         // own predecessor, or in blocks with predecessors
         // that are not reachable.
         if (P == CurrentBlock) {
           NumWithout = 2;
           break;
         } else if (!DT->isReachableFromEntry(P))  {
           NumWithout = 2;
while (!NewDead.empty()) {
     SmallVector<BasicBlock *, 8> Dom;
     DT->getDescendants(D, Dom);
     DeadBlocks.insert(Dom.begin(), Dom.end());
     
     // Figure out the dominance-frontier(D).
     for (SmallVectorImpl<BasicBlock *>::iterator I = Dom.begin(),
            E = Dom.end(); I != E; I++) {
       BasicBlock *B = *I;
-      for (succ_iterator SI = succ_begin(B), SE = succ_end(B); SI != SE; SI++) {
-        BasicBlock *S = *SI;
+      for (BasicBlock *S : successors(B)) {
         if (DeadBlocks.count(S))
           continue;
 
         bool AllPredDead = true;
-        for (pred_iterator PI = pred_begin(S), PE = pred_end(S); PI != PE; PI++)
-          if (!DeadBlocks.count(*PI)) {
+        for (BasicBlock *Pred : predecessors(S))
+          if (!DeadBlocks.count(Pred)) {
             AllPredDead = false;
             break;
           }
 
         if (!AllPredDead) {
           // S could be proved dead later on. That is why we don't update phi
           // operands at this moment.
           DF.insert(S);

lib/Transforms/Scalar/JumpThreading.cpp

if (!RecursionSet.insert(std::make_pair(V, BB)).second)
     return false;
 
   // An RAII help to remove this pair from the recursion set once the recursion
   // stack pops back out again.
   RecursionSetRemover remover(RecursionSet, std::make_pair(V, BB));
 
   // If V is a constant, then it is known in all predecessors.
   if (Constant *KC = getKnownConstant(V, Preference)) {
-    for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
-      Result.push_back(std::make_pair(KC, *PI));
+    for (BasicBlock *Pred : predecessors(BB))
+      Result.push_back(std::make_pair(KC, Pred));
 
     return true;
   }
 
   // If V is a non-instruction value, or an instruction in a different block,
   // then it can't be derived from a PHI.
   Instruction *I = dyn_cast<Instruction>(V);
   if (!I || I->getParent() != BB) {
 
     // Okay, if this is a live-in value, see if it has a known value at the end
     // of any of our predecessors.
     //
     // FIXME: This should be an edge property, not a block end property.
     /// TODO: Per PR2563, we could infer value range information about a
     /// predecessor based on its terminator.
     //
     // FIXME: change this to use the more-rich 'getPredicateOnEdge' method if
     // "I" is a non-local compare-with-a-constant instruction.  This would be
     // able to handle value inequalities better, for example if the compare is
     // "X < 4" and "X < 3" is known true but "X < 4" itself is not available.
     // Perhaps getConstantOnEdge should be smart enough to do this?
 
-    for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-      BasicBlock *P = *PI;
+    for (BasicBlock *P : predecessors(BB)) {
       // If the value is known by LazyValueInfo to be a constant in a
       // predecessor, use that information to try to thread this block.
       Constant *PredCst = LVI->getConstantOnEdge(V, P, BB);
       if (Constant *KC = getKnownConstant(PredCst, Preference))
         Result.push_back(std::make_pair(KC, P));
     }
 
     return !Result.empty();
if (CmpInst *Cmp = dyn_cast<CmpInst>(I)) {
 
     // If comparing a live-in value against a constant, see if we know the
     // live-in value on any predecessors.
     if (isa<Constant>(Cmp->getOperand(1)) && Cmp->getType()->isIntegerTy()) {
       if (!isa<Instruction>(Cmp->getOperand(0)) ||
           cast<Instruction>(Cmp->getOperand(0))->getParent() != BB) {
         Constant *RHSCst = cast<Constant>(Cmp->getOperand(1));
 
-        for (pred_iterator PI = pred_begin(BB), E = pred_end(BB);PI != E; ++PI){
-          BasicBlock *P = *PI;
+        for (BasicBlock *P : predecessors(BB)) {
           // If the value is known by LazyValueInfo to be a constant in a
           // predecessor, use that information to try to thread this block.
           LazyValueInfo::Tristate Res =
             LVI->getPredicateOnEdge(Cmp->getPredicate(), Cmp->getOperand(0),
                                     RHSCst, P, BB);
           if (Res == LazyValueInfo::Unknown)
             continue;
 
if ((TrueVal || FalseVal) &&
 
       return !Result.empty();
     }
   }
 
   // If all else fails, see if LVI can figure out a constant value for us.
   Constant *CI = LVI->getConstant(V, BB);
   if (Constant *KC = getKnownConstant(CI, Preference)) {
-    for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
-      Result.push_back(std::make_pair(KC, *PI));
+    for (BasicBlock *Pred : predecessors(BB))
+      Result.push_back(std::make_pair(KC, Pred));
   }
 
   return !Result.empty();
 }
 
 
 
 /// GetBestDestForBranchOnUndef - If we determine that the specified block ends
bool JumpThreading::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
 
   SmallPtrSet<BasicBlock*, 8> PredsScanned;
   typedef SmallVector<std::pair<BasicBlock*, Value*>, 8> AvailablePredsTy;
   AvailablePredsTy AvailablePreds;
   BasicBlock *OneUnavailablePred = nullptr;
 
   // If we got here, the loaded value is transparent through to the start of the
   // block.  Check to see if it is available in any of the predecessor blocks.
-  for (pred_iterator PI = pred_begin(LoadBB), PE = pred_end(LoadBB);
-       PI != PE; ++PI) {
-    BasicBlock *PredBB = *PI;
-
+  for (BasicBlock *PredBB : predecessors(LoadBB)) {
     // If we already scanned this predecessor, skip it.
     if (!PredsScanned.insert(PredBB))
       continue;
 
     // Scan the predecessor to see if the value is available in the pred.
     BBIt = PredBB->end();
     MDNode *ThisTBAATag = nullptr;
     Value *PredAvailable = FindAvailableLoadedValue(LoadedPtr, PredBB, BBIt, 6,
if (PredsScanned.size() == AvailablePreds.size()+1 &&
     // edge from the one.
     SmallVector<BasicBlock*, 8> PredsToSplit;
     SmallPtrSet<BasicBlock*, 8> AvailablePredSet;
 
     for (unsigned i = 0, e = AvailablePreds.size(); i != e; ++i)
       AvailablePredSet.insert(AvailablePreds[i].first);
 
     // Add all the unavailable predecessors to the PredsToSplit list.
-    for (pred_iterator PI = pred_begin(LoadBB), PE = pred_end(LoadBB);
-         PI != PE; ++PI) {
-      BasicBlock *P = *PI;
+    for (BasicBlock *P : predecessors(LoadBB)) {
       // If the predecessor is an indirect goto, we can't split the edge.
       if (isa<IndirectBrInst>(P->getTerminator()))
         return false;
 
       if (!AvailablePredSet.count(P))
         PredsToSplit.push_back(P);
     }
 

lib/Transforms/Scalar/LoopInstSimplify.cpp

while (!VisitStack.empty()) {
         if (IsSubloopHeader && !isa<PHINode>(I))
           break;
       }
 
       // Add all successors to the worklist, except for loop exit blocks and the
       // bodies of subloops. We visit the headers of loops so that we can process
       // their phis, but we contract the rest of the subloop body and only follow
       // edges leading back to the original loop.
-      for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE;
-           ++SI) {
-        BasicBlock *SuccBB = *SI;
+      for (BasicBlock *SuccBB : successors(BB)) {
         if (!Visited.insert(SuccBB))
           continue;
 
         const Loop *SuccLoop = LI->getLoopFor(SuccBB);
         if (SuccLoop && SuccLoop->getHeader() == SuccBB
                      && L->contains(SuccLoop)) {
           VisitStack.push_back(WorklistItem(SuccBB, true));
 

lib/Transforms/Scalar/LoopUnswitch.cpp

if (!L->contains(BB)) {
     // Otherwise, this is a loop exit, this is fine so long as this is the
     // first exit.
     if (ExitBB) return false;
     ExitBB = BB;
     return true;
   }
 
   // Otherwise, this is an unvisited intra-loop node.  Check all successors.
-  for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI) {
+  for (BasicBlock *Succ : successors(BB)) {
     // Check to see if the successor is a trivial loop exit.
-    if (!isTrivialLoopExitBlockHelper(L, *SI, ExitBB, Visited))
+    if (!isTrivialLoopExitBlockHelper(L, Succ, ExitBB, Visited))
       return false;
   }
 
   // Okay, everything after this looks good, check to make sure that this block
   // doesn't include any side effects.
   for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
     if (I->mayHaveSideEffects())
       return false;
for (BasicBlock::iterator I = ExitSucc->begin();
       if (It != VMap.end()) V = It->second;
       PN->addIncoming(V, NewExit);
     }
 
     if (LandingPadInst *LPad = NewExit->getLandingPadInst()) {
       PHINode *PN = PHINode::Create(LPad->getType(), 0, "",
                                     ExitSucc->getFirstInsertionPt());
 
-      for (pred_iterator I = pred_begin(ExitSucc), E = pred_end(ExitSucc);
-           I != E; ++I) {
-        BasicBlock *BB = *I;
+      for (BasicBlock *BB : predecessors(ExitSucc)) {
         LandingPadInst *LPI = BB->getLandingPadInst();
         LPI->replaceAllUsesWith(PN);
         PN->addIncoming(LPI, BB);
       }
     }
   }
 
   // Rewrite the code to refer to itself.

lib/Transforms/Scalar/SampleProfile.cpp

 void SampleFunctionProfile::buildEdges(Function &F) {
   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
     BasicBlock *B1 = I;
 
     // Add predecessors for B1.
     SmallPtrSet<BasicBlock *, 16> Visited;
     if (!Predecessors[B1].empty())
       llvm_unreachable("Found a stale predecessors list in a basic block.");
-    for (pred_iterator PI = pred_begin(B1), PE = pred_end(B1); PI != PE; ++PI) {
-      BasicBlock *B2 = *PI;
+    for (BasicBlock *B2 : predecessors(B1)) {
       if (Visited.insert(B2))
         Predecessors[B1].push_back(B2);
     }
 
     // Add successors for B1.
     Visited.clear();
     if (!Successors[B1].empty())
       llvm_unreachable("Found a stale successors list in a basic block.");
-    for (succ_iterator SI = succ_begin(B1), SE = succ_end(B1); SI != SE; ++SI) {
-      BasicBlock *B2 = *SI;
+    for (BasicBlock *B2 : successors(B1)) {
       if (Visited.insert(B2))
         Successors[B1].push_back(B2);
     }
   }
 }
 
 /// \brief Propagate weights into edges
 ///

lib/Transforms/Scalar/Sink.cpp

for (DomTreeNode::iterator I = DTN->begin(), E = DTN->end();
     BasicBlock *Candidate = (*I)->getBlock();
     if ((*I)->getIDom()->getBlock() == Inst->getParent() &&
         IsAcceptableTarget(Inst, Candidate))
       SuccToSinkTo = Candidate;
   }
 
   // If no suitable postdominator was found, look at all the successors and
   // decide which one we should sink to, if any.
-  for (succ_iterator I = succ_begin(Inst->getParent()),
-      E = succ_end(Inst->getParent()); I != E && !SuccToSinkTo; ++I) {
-    if (IsAcceptableTarget(Inst, *I))
-      SuccToSinkTo = *I;
+  for (BasicBlock *Succ : successors(Inst->getParent())) {
+    if (SuccToSinkTo)
+      break;
+    if (IsAcceptableTarget(Inst, Succ))
+      SuccToSinkTo = Succ;
   }
 
   // If we couldn't find a block to sink to, ignore this instruction.
   if (!SuccToSinkTo)
     return false;
 
   DEBUG(dbgs() << "Sink" << *Inst << " (";
         Inst->getParent()->printAsOperand(dbgs(), false);
         dbgs() << " -> ";
         SuccToSinkTo->printAsOperand(dbgs(), false);
         dbgs() << ")\n");
 
   // Move the instruction.
   Inst->moveBefore(SuccToSinkTo->getFirstInsertionPt());
   return true;
 }

lib/Transforms/Scalar/StructurizeCFG.cpp

 
 /// \brief Analyze the predecessors of each block and build up predicates
 void StructurizeCFG::gatherPredicates(RegionNode *N) {
   RegionInfo *RI = ParentRegion->getRegionInfo();
   BasicBlock *BB = N->getEntry();
   BBPredicates &Pred = Predicates[BB];
   BBPredicates &LPred = LoopPreds[BB];
 
-  for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
-       PI != PE; ++PI) {
-
+  for (BasicBlock *Predecessor : predecessors(BB)) {
     // Ignore it if it's a branch from outside into our region entry
-    if (!ParentRegion->contains(*PI))
+    if (!ParentRegion->contains(Predecessor))
       continue;
 
-    Region *R = RI->getRegionFor(*PI);
+    Region *R = RI->getRegionFor(Predecessor);
     if (R == ParentRegion) {
 
       // It's a top level block in our region
-      BranchInst *Term = cast<BranchInst>((*PI)->getTerminator());
+      BranchInst *Term = cast<BranchInst>(Predecessor->getTerminator());
       for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) {
         BasicBlock *Succ = Term->getSuccessor(i);
         if (Succ != BB)
           continue;
 
-        if (Visited.count(*PI)) {
+        if (Visited.count(Predecessor)) {
           // Normal forward edge
           if (Term->isConditional()) {
             // Try to treat it like an ELSE block
             BasicBlock *Other = Term->getSuccessor(!i);
             if (Visited.count(Other) && !Loops.count(Other) &&
-                !Pred.count(Other) && !Pred.count(*PI)) {
+                !Pred.count(Other) && !Pred.count(Predecessor)) {
 
               Pred[Other] = BoolFalse;
-              Pred[*PI] = BoolTrue;
+              Pred[Predecessor] = BoolTrue;
               continue;
             }
           }
-          Pred[*PI] = buildCondition(Term, i, false);
+          Pred[Predecessor] = buildCondition(Term, i, false);
 
         } else {
           // Back edge
-          LPred[*PI] = buildCondition(Term, i, true);
+          LPred[Predecessor] = buildCondition(Term, i, true);
         }
       }
 
     } else {
 
       // It's an exit from a sub region
       while(R->getParent() != ParentRegion)
         R = R->getParent();

 }
 
 /// \brief Remove phi values from all successors and then remove the terminator.
 void StructurizeCFG::killTerminator(BasicBlock *BB) {
   TerminatorInst *Term = BB->getTerminator();
   if (!Term)
     return;
 
-  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB);
-       SI != SE; ++SI) {
-
-    delPhiValues(BB, *SI);
-  }
+  for (BasicBlock *Succ : successors(BB))
+    delPhiValues(BB, Succ);
 
   Term->eraseFromParent();
 }
 
 /// \brief Let node exit(s) point to NewExit
 void StructurizeCFG::changeExit(RegionNode *Node, BasicBlock *NewExit,
                                 bool IncludeDominator) {
   if (Node->isSubRegion()) {
     Region *SubRegion = Node->getNodeAs<Region>();
     BasicBlock *OldExit = SubRegion->getExit();
     BasicBlock *Dominator = nullptr;
 
     // Find all the edges from the sub region to the exit
-    for (pred_iterator I = pred_begin(OldExit), E = pred_end(OldExit);
-         I != E;) {
-
-      BasicBlock *BB = *I++;
+    for (BasicBlock *BB : predecessors(OldExit)) {
       if (!SubRegion->contains(BB))
         continue;
 
       // Modify the edges to point to the new exit
       delPhiValues(BB, OldExit);
       BB->getTerminator()->replaceUsesOfWith(OldExit, NewExit);
       addPhiValues(BB, NewExit);
 

lib/Transforms/Scalar/TailRecursionElimination.cpp

for (auto &I : *BB) {
 
       if (Escaped == UNESCAPED && !Tracker.AllocaUsers.count(CI)) {
         DeferredTails.push_back(CI);
       } else {
         AllCallsAreTailCalls = false;
       }
     }
 
-    for (auto *SuccBB : make_range(succ_begin(BB), succ_end(BB))) {
+    for (auto *SuccBB : successors(BB)) {
       auto &State = Visited[SuccBB];
       if (State < Escaped) {
         State = Escaped;
         if (State == ESCAPED)
           WorklistEscaped.push_back(SuccBB);
         else
           WorklistUnescaped.push_back(SuccBB);
       }
bool TailCallElim::FoldReturnAndProcessPred(BasicBlock *BB,
                                        bool CannotTailCallElimCallsMarkedTail) {
   bool Change = false;
 
   // If the return block contains nothing but the return and PHI's,
   // there might be an opportunity to duplicate the return in its
   // predecessors and perform TRC there. Look for predecessors that end
   // in unconditional branch and recursive call(s).
   SmallVector<BranchInst*, 8> UncondBranchPreds;
-  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-    BasicBlock *Pred = *PI;
+  for (BasicBlock *Pred : predecessors(BB)) {
     TerminatorInst *PTI = Pred->getTerminator();
     if (BranchInst *BI = dyn_cast<BranchInst>(PTI))
       if (BI->isUnconditional())
         UncondBranchPreds.push_back(BI);
   }
 
   while (!UncondBranchPreds.empty()) {
     BranchInst *BI = UncondBranchPreds.pop_back_val();

lib/Transforms/Utils/BasicBlockUtils.cpp

void llvm::SplitLandingPadPredecessors(BasicBlock *OrigBB,
   bool HasLoopExit = false;
   UpdateAnalysisInformation(OrigBB, NewBB1, Preds, P, HasLoopExit);
 
   // Update the PHI nodes in OrigBB with the values coming from NewBB1.
   UpdatePHINodes(OrigBB, NewBB1, Preds, BI1, P, HasLoopExit);
 
   // Move the remaining edges from OrigBB to point to NewBB2.
   SmallVector<BasicBlock*, 8> NewBB2Preds;
-  for (pred_iterator i = pred_begin(OrigBB), e = pred_end(OrigBB);
-       i != e; ) {
-    BasicBlock *Pred = *i++;
+  for (BasicBlock *Pred : predecessors(OrigBB)) {
     if (Pred == NewBB1) continue;
     assert(!isa<IndirectBrInst>(Pred->getTerminator()) &&
            "Cannot split an edge from an IndirectBrInst");
     NewBB2Preds.push_back(Pred);
-    e = pred_end(OrigBB);
   }
 
   BasicBlock *NewBB2 = nullptr;
   if (!NewBB2Preds.empty()) {
     // Create another basic block for the rest of OrigBB's predecessors.
     NewBB2 = BasicBlock::Create(OrigBB->getContext(),
                                 OrigBB->getName() + Suffix2,
                                 OrigBB->getParent(), OrigBB);

lib/Transforms/Utils/BreakCriticalEdges.cpp

BasicBlock *llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum,
 
   // If there is a PHI in the block, loop over predecessors with it, which is
   // faster than iterating pred_begin/end.
   if (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
     for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
       if (PN->getIncomingBlock(i) != NewBB)
         OtherPreds.push_back(PN->getIncomingBlock(i));
   } else {
-    for (pred_iterator I = pred_begin(DestBB), E = pred_end(DestBB);
-         I != E; ++I) {
-      BasicBlock *P = *I;
+    for (BasicBlock *P : predecessors(DestBB)) {
       if (P != NewBB)
         OtherPreds.push_back(P);
     }
   }
 
   bool NewBBDominatesDestBB = true;
 
   // Should we update DominatorTree information?
if (Loop *TIL = LI->getLoopFor(TIBB)) {
         // *and* the only edge into DestBB from outside of TIL is that of
         // NewBB. If the first isn't true, then LoopSimplify still holds, NewBB
         // is the new exit block and it has no non-loop predecessors. If the
         // second isn't true, then DestBB was not in LoopSimplify form prior to
         // the split as it had a non-loop predecessor. In both of these cases,
         // the predecessor must be directly in TIL, not in a subloop, or again
         // LoopSimplify doesn't hold.
         SmallVector<BasicBlock *, 4> LoopPreds;
-        for (pred_iterator I = pred_begin(DestBB), E = pred_end(DestBB); I != E;
-             ++I) {
-          BasicBlock *P = *I;
+        for (BasicBlock *P : predecessors(DestBB)) {
           if (P == NewBB)
             continue; // The new block is known.
           if (LI->getLoopFor(P) != TIL) {
             // No need to re-simplify, it wasn't to start with.
             LoopPreds.clear();
             break;
           }
           LoopPreds.push_back(P);

lib/Transforms/Utils/CloneFunction.cpp

for (unsigned phino = 0, e = PHIToResolve.size(); phino != e; ) {
     // phi nodes will have invalid entries.  Update the PHI nodes in this
     // case.
     PHINode *PN = cast<PHINode>(NewBB->begin());
     NumPreds = std::distance(pred_begin(NewBB), pred_end(NewBB));
     if (NumPreds != PN->getNumIncomingValues()) {
       assert(NumPreds < PN->getNumIncomingValues());
       // Count how many times each predecessor comes to this block.
       std::map<BasicBlock*, unsigned> PredCount;
-      for (pred_iterator PI = pred_begin(NewBB), E = pred_end(NewBB);
-           PI != E; ++PI)
-        --PredCount[*PI];
+      for (BasicBlock *Pred : predecessors(NewBB))
+        --PredCount[Pred];
       
       // Figure out how many entries to remove from each PHI.
       for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
         ++PredCount[PN->getIncomingBlock(i)];
       
       // At this point, the excess predecessor entries are positive in the
       // map.  Loop over all of the PHIs and remove excess predecessor
       // entries.

lib/Transforms/Utils/CodeExtractor.cpp

if (!isBlockValidForExtraction(**I)) {
       return Result;
     }
   }
 
 #ifndef NDEBUG
   for (SetVector<BasicBlock *>::iterator I = std::next(Result.begin()),
                                          E = Result.end();
        I != E; ++I)
-    for (pred_iterator PI = pred_begin(*I), PE = pred_end(*I);
-         PI != PE; ++PI)
-      assert(Result.count(*PI) &&
+    for (BasicBlock *Pred : predecessors(*I))
+      assert(Result.count(Pred) &&
              "No blocks in this region may have entries from outside the region"
              " except for the first block!");
 #endif
 
   return Result;
 }
 
 /// \brief Helper to call buildExtractionBlockSet with an ArrayRef.
Function *CodeExtractor::extractCodeRegion() {
   newFuncRoot->getInstList().push_back(BranchInst::Create(header));
 
   // Find inputs to, outputs from the code region.
   findInputsOutputs(inputs, outputs);
 
   SmallPtrSet<BasicBlock *, 1> ExitBlocks;
   for (SetVector<BasicBlock *>::iterator I = Blocks.begin(), E = Blocks.end();
        I != E; ++I)
-    for (succ_iterator SI = succ_begin(*I), SE = succ_end(*I); SI != SE; ++SI)
-      if (!Blocks.count(*SI))
-        ExitBlocks.insert(*SI);
+    for (BasicBlock *Succ : successors(*I))
+      if (!Blocks.count(Succ))
+        ExitBlocks.insert(Succ);
   NumExitBlocks = ExitBlocks.size();
 
   // Construct new function based on inputs/outputs & add allocas for all defs.
   Function *newFunction = constructFunction(inputs, outputs, header,
                                             newFuncRoot,
                                             codeReplacer, oldFunction,
                                             oldFunction->getParent());
 

lib/Transforms/Utils/Local.cpp

 }
 
 /// changeToUnreachable - Insert an unreachable instruction before the specified
 /// instruction, making it and the rest of the code in the block dead.
 static void changeToUnreachable(Instruction *I, bool UseLLVMTrap) {
   BasicBlock *BB = I->getParent();
   // Loop over all of the successors, removing BB's entry from any PHI
   // nodes.
-  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
-    (*SI)->removePredecessor(BB);
+  for (BasicBlock *Succ : successors(BB))
+    Succ->removePredecessor(BB);
 
   // Insert a call to llvm.trap right before this.  This turns the undefined
   // behavior into a hard fail instead of falling through into random code.
   if (UseLLVMTrap) {
     Function *TrapFn =
       Intrinsic::getDeclaration(BB->getParent()->getParent(), Intrinsic::trap);
     CallInst *CallTrap = CallInst::Create(TrapFn, "", I);
     CallTrap->setDebugLoc(I->getDebugLoc());
if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) {
           II->eraseFromParent();
         } else
           changeToCall(II);
         Changed = true;
       }
     }
 
     Changed |= ConstantFoldTerminator(BB, true);
-    for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
-      if (Reachable.insert(*SI))
-        Worklist.push_back(*SI);
+    for (BasicBlock *Succ : successors(BB))
+      if (Reachable.insert(Succ))
+        Worklist.push_back(Succ);
   } while (!Worklist.empty());
   return Changed;
 }
 
 /// removeUnreachableBlocksFromFn - Remove blocks that are not reachable, even
 /// if they are in a dead cycle.  Return true if a change was made, false
 /// otherwise.
 bool llvm::removeUnreachableBlocks(Function &F) {
   SmallPtrSet<BasicBlock*, 128> Reachable;
   bool Changed = markAliveBlocks(F.begin(), Reachable);
 
   // If there are unreachable blocks in the CFG...
   if (Reachable.size() == F.size())
     return Changed;
 
   assert(Reachable.size() < F.size());
   NumRemoved += F.size()-Reachable.size();
 
   // Loop over all of the basic blocks that are not reachable, dropping all of
   // their internal references...
   for (Function::iterator BB = ++F.begin(), E = F.end(); BB != E; ++BB) {
     if (Reachable.count(BB))
       continue;
 
-    for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
-      if (Reachable.count(*SI))
-        (*SI)->removePredecessor(BB);
+    for (BasicBlock *Succ : successors(BB))
+      if (Reachable.count(Succ))
+        Succ->removePredecessor(BB);
     BB->dropAllReferences();
   }
 
   for (Function::iterator I = ++F.begin(); I != F.end();)
     if (!Reachable.count(I))
       I = F.getBasicBlockList().erase(I);
     else
       ++I;
 
   return true;
 }

lib/Transforms/Utils/LoopSimplify.cpp

 /// preheader, this method is called to insert one.  This method has two phases:
 /// preheader insertion and analysis updating.
 ///
 BasicBlock *llvm::InsertPreheaderForLoop(Loop *L, Pass *PP) {
   BasicBlock *Header = L->getHeader();
 
   // Compute the set of predecessors of the loop that are not in the loop.
   SmallVector<BasicBlock*, 8> OutsideBlocks;
-  for (pred_iterator PI = pred_begin(Header), PE = pred_end(Header);
-       PI != PE; ++PI) {
-    BasicBlock *P = *PI;
+  for (BasicBlock *P : predecessors(Header)) {
     if (!L->contains(P)) {         // Coming in from outside the loop?
       // If the loop is branched to from an indirect branch, we won't
       // be able to fully transform the loop, because it prohibits
       // edge splitting.
       if (isa<IndirectBrInst>(P->getTerminator())) return nullptr;
 
       // Keep track of it.
       OutsideBlocks.push_back(P);

 }
 
 /// \brief Ensure that the loop preheader dominates all exit blocks.
 ///
 /// This method is used to split exit blocks that have predecessors outside of
 /// the loop.
 static BasicBlock *rewriteLoopExitBlock(Loop *L, BasicBlock *Exit, Pass *PP) {
   SmallVector<BasicBlock*, 8> LoopBlocks;
-  for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit); I != E; ++I) {
-    BasicBlock *P = *I;
+  for (BasicBlock *P : predecessors(Exit)) {
     if (L->contains(P)) {
       // Don't do this if the loop is exited via an indirect branch.
       if (isa<IndirectBrInst>(P->getTerminator())) return nullptr;
 
       LoopBlocks.push_back(P);
     }
   }
 
static void addBlockAndPredsToSet(BasicBlock *InputBB, BasicBlock *StopBlock,
                                   std::set<BasicBlock*> &Blocks) {
   SmallVector<BasicBlock *, 8> Worklist;
   Worklist.push_back(InputBB);
   do {
     BasicBlock *BB = Worklist.pop_back_val();
     if (Blocks.insert(BB).second && BB != StopBlock)
       // If BB is not already processed and it is not a stop block then
       // insert its predecessor in the work list
-      for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
-        BasicBlock *WBB = *I;
+      for (BasicBlock *WBB : predecessors(BB))
         Worklist.push_back(WBB);
-      }
   } while (!Worklist.empty());
 }
 
 /// \brief The first part of loop-nestification is to find a PHI node that tells
 /// us how to partition the loops.
 static PHINode *findPHIToPartitionLoops(Loop *L, AliasAnalysis *AA,
                                         DominatorTree *DT) {
   for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) {
static Loop *separateNestedLoop(Loop *L, BasicBlock *Preheader,
 
   // Now reset the header in L, which had been moved by
   // SplitBlockPredecessors for the outer loop.
   L->moveToHeader(Header);
 
   // Determine which blocks should stay in L and which should be moved out to
   // the Outer loop now.
   std::set<BasicBlock*> BlocksInL;
-  for (pred_iterator PI=pred_begin(Header), E = pred_end(Header); PI!=E; ++PI) {
-    BasicBlock *P = *PI;
+  for (BasicBlock *P : predecessors(Header)) {
     if (DT->dominates(Header, P))
       addBlockAndPredsToSet(P, Header, BlocksInL);
   }
 
   // Scan all of the loop children of L, moving them to OuterLoop if they are
   // not part of the inner loop.
   const std::vector<Loop*> &SubLoops = L->getSubLoops();
   for (size_t I = 0; I != SubLoops.size(); )
static BasicBlock *insertUniqueBackedgeBlock(Loop *L, BasicBlock *Preheader,
   if (!Preheader)
     return nullptr;
 
   // The header is not a landing pad; preheader insertion should ensure this.
   assert(!Header->isLandingPad() && "Can't insert backedge to landing pad");
 
   // Figure out which basic blocks contain back-edges to the loop header.
   std::vector<BasicBlock*> BackedgeBlocks;
-  for (pred_iterator I = pred_begin(Header), E = pred_end(Header); I != E; ++I){
-    BasicBlock *P = *I;
-
+  for (BasicBlock *P : predecessors(Header)) {
     // Indirectbr edges cannot be split, so we must fail if we find one.
     if (isa<IndirectBrInst>(P->getTerminator()))
       return nullptr;
 
     if (P != Preheader) BackedgeBlocks.push_back(P);
   }
 
   // Create and insert the new backedge block...
ReprocessLoop:
   // predecessors that are not in the loop.  This is not valid for natural
   // loops, but can occur if the blocks are unreachable.  Since they are
   // unreachable we can just shamelessly delete those CFG edges!
   for (Loop::block_iterator BB = L->block_begin(), E = L->block_end();
        BB != E; ++BB) {
     if (*BB == L->getHeader()) continue;
 
     SmallPtrSet<BasicBlock*, 4> BadPreds;
-    for (pred_iterator PI = pred_begin(*BB),
-         PE = pred_end(*BB); PI != PE; ++PI) {
-      BasicBlock *P = *PI;
+    for (BasicBlock *P : predecessors(*BB)) {
       if (!L->contains(P))
         BadPreds.insert(P);
     }
 
     // Delete each unique out-of-loop (and thus dead) predecessor.
     for (SmallPtrSet<BasicBlock*, 4>::iterator I = BadPreds.begin(),
          E = BadPreds.end(); I != E; ++I) {
 
       DEBUG(dbgs() << "LoopSimplify: Deleting edge from dead predecessor "
                    << (*I)->getName() << "\n");
 
       // Inform each successor of each dead pred.
-      for (succ_iterator SI = succ_begin(*I), SE = succ_end(*I); SI != SE; ++SI)
-        (*SI)->removePredecessor(*I);
+      for (BasicBlock *Succ : successors(*I))
+        Succ->removePredecessor(*I);
       // Zap the dead pred's terminator and replace it with unreachable.
       TerminatorInst *TI = (*I)->getTerminator();
        TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
       (*I)->getTerminator()->eraseFromParent();
       new UnreachableInst((*I)->getContext(), *I);
       Changed = true;
     }
   }
ReprocessLoop:
   SmallVector<BasicBlock*, 8> ExitBlocks;
   L->getExitBlocks(ExitBlocks);
 
   SmallSetVector<BasicBlock *, 8> ExitBlockSet(ExitBlocks.begin(),
                                                ExitBlocks.end());
   for (SmallSetVector<BasicBlock *, 8>::iterator I = ExitBlockSet.begin(),
          E = ExitBlockSet.end(); I != E; ++I) {
     BasicBlock *ExitBlock = *I;
-    for (pred_iterator PI = pred_begin(ExitBlock), PE = pred_end(ExitBlock);
-         PI != PE; ++PI)
+    for (BasicBlock *Pred : predecessors(ExitBlock))
       // Must be exactly this loop: no subloops, parent loops, or non-loop preds
       // allowed.
-      if (!L->contains(*PI)) {
+      if (!L->contains(Pred)) {
         if (rewriteLoopExitBlock(L, ExitBlock, PP)) {
           ++NumInserted;
           Changed = true;
         }
         break;
       }
   }
 

lib/Transforms/Utils/LoopUnroll.cpp

for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) {
       LastValueMap[*BB] = New;
       for (ValueToValueMapTy::iterator VI = VMap.begin(), VE = VMap.end();
            VI != VE; ++VI)
         LastValueMap[VI->first] = VI->second;
 
       L->addBasicBlockToLoop(New, LI->getBase());
 
       // Add phi entries for newly created values to all exit blocks.
-      for (succ_iterator SI = succ_begin(*BB), SE = succ_end(*BB);
-           SI != SE; ++SI) {
-        if (L->contains(*SI))
+      for (BasicBlock *Succ : successors(*BB)) {
+        if (L->contains(Succ))
           continue;
-        for (BasicBlock::iterator BBI = (*SI)->begin();
+        for (BasicBlock::iterator BBI = Succ->begin();
              PHINode *phi = dyn_cast<PHINode>(BBI); ++BBI) {
           Value *Incoming = phi->getIncomingValueForBlock(*BB);
           ValueToValueMapTy::iterator It = LastValueMap.find(Incoming);
           if (It != LastValueMap.end())
             Incoming = It->second;
           phi->addIncoming(Incoming, New);
         }
       }
for (unsigned i = 0, e = Latches.size(); i != e; ++i) {
     if (NeedConditional) {
       // Update the conditional branch's successor for the following
       // iteration.
       Term->setSuccessor(!ContinueOnTrue, Dest);
     } else {
       // Remove phi operands at this loop exit
       if (Dest != LoopExit) {
         BasicBlock *BB = Latches[i];
-        for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB);
-             SI != SE; ++SI) {
-          if (*SI == Headers[i])
+        for (BasicBlock *Succ : successors(BB)) {
+          if (Succ == Headers[i])
             continue;
-          for (BasicBlock::iterator BBI = (*SI)->begin();
+          for (BasicBlock::iterator BBI = Succ->begin();
                PHINode *Phi = dyn_cast<PHINode>(BBI); ++BBI) {
             Phi->removeIncomingValue(BB, false);
           }
         }
       }
       // Replace the conditional branch with an unconditional one.
       BranchInst::Create(Dest, Term);
       Term->eraseFromParent();

lib/Transforms/Utils/LoopUnrollRuntime.cpp

static void ConnectProlog(Loop *L, Value *TripCount, unsigned Count,
   BasicBlock *Latch = L->getLoopLatch();
   assert(Latch && "Loop must have a latch");
 
   // Create a PHI node for each outgoing value from the original loop
   // (which means it is an outgoing value from the prolog code too).
   // The new PHI node is inserted in the prolog end basic block.
   // The new PHI name is added as an operand of a PHI node in either
   // the loop header or the loop exit block.
-  for (succ_iterator SBI = succ_begin(Latch), SBE = succ_end(Latch);
-       SBI != SBE; ++SBI) {
-    for (BasicBlock::iterator BBI = (*SBI)->begin();
+  for (BasicBlock *Succ : successors(Latch)) {
+    for (BasicBlock::iterator BBI = Succ->begin();
          PHINode *PN = dyn_cast<PHINode>(BBI); ++BBI) {
 
       // Add a new PHI node to the prolog end block and add the
       // appropriate incoming values.
       PHINode *NewPN = PHINode::Create(PN->getType(), 2, PN->getName()+".unr",
                                        PrologEnd->getTerminator());
       // Adding a value to the new PHI node from the original loop preheader.
       // This is the value that skips all the prolog code.

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

while (!LiveInBlockWorklist.empty()) {
     // The block really is live in here, insert it into the set.  If already in
     // the set, then it has already been processed.
     if (!LiveInBlocks.insert(BB))
       continue;
 
     // Since the value is live into BB, it is either defined in a predecessor or
     // live into it to.  Add the preds to the worklist unless they are a
     // defining block.
-    for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-      BasicBlock *P = *PI;
-
+    for (BasicBlock *P : predecessors(BB)) {
       // The value is not live into a predecessor if it defines the value.
       if (DefBlocks.count(P))
         continue;
 
       // Otherwise it is, add to the worklist.
       LiveInBlockWorklist.push_back(P);
     }
   }
while (!PQ.empty()) {
 
     Worklist.clear();
     Worklist.push_back(Root);
 
     while (!Worklist.empty()) {
       DomTreeNode *Node = Worklist.pop_back_val();
       BasicBlock *BB = Node->getBlock();
 
-      for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE;
-           ++SI) {
-        DomTreeNode *SuccNode = DT.getNode(*SI);
+      for (BasicBlock *Succ : successors(BB)) {
+        DomTreeNode *SuccNode = DT.getNode(Succ);
 
         // Quickly skip all CFG edges that are also dominator tree edges instead
         // of catching them below.
         if (SuccNode->getIDom() == Node)
           continue;
 
         unsigned SuccLevel = DomLevels[SuccNode];
         if (SuccLevel > RootLevel)

lib/Transforms/Utils/SSAUpdater.cpp

for (unsigned i = 0, e = SomePhi->getNumIncomingValues(); i != e; ++i) {
       // Compute SingularValue.
       if (i == 0)
         SingularValue = PredVal;
       else if (PredVal != SingularValue)
         SingularValue = nullptr;
     }
   } else {
     bool isFirstPred = true;
-    for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-      BasicBlock *PredBB = *PI;
+    for (BasicBlock *PredBB : predecessors(BB)) {
       Value *PredVal = GetValueAtEndOfBlock(PredBB);
       PredValues.push_back(std::make_pair(PredBB, PredVal));
 
       // Compute SingularValue.
       if (isFirstPred) {
         SingularValue = PredVal;
         isFirstPred = false;
       } else if (PredVal != SingularValue)
static void FindPredecessorBlocks(BasicBlock *BB,
                                     SmallVectorImpl<BasicBlock*> *Preds) {
     // We can get our predecessor info by walking the pred_iterator list,
     // but it is relatively slow.  If we already have PHI nodes in this
     // block, walk one of them to get the predecessor list instead.
     if (PHINode *SomePhi = dyn_cast<PHINode>(BB->begin())) {
       for (unsigned PI = 0, E = SomePhi->getNumIncomingValues(); PI != E; ++PI)
         Preds->push_back(SomePhi->getIncomingBlock(PI));
     } else {
-      for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
-        Preds->push_back(*PI);
+      Preds->insert(Preds->end(), pred_begin(BB), pred_end(BB));
     }
   }
 
   /// GetUndefVal - Get an undefined value of the same type as the value
   /// being handled.
   static Value *GetUndefVal(BasicBlock *BB, SSAUpdater *Updater) {
     return UndefValue::get(Updater->ProtoType);
   }

lib/Transforms/Utils/SimplifyCFG.cpp

static bool SafeToMergeTerminators(TerminatorInst *SI1, TerminatorInst *SI2) {
 
   // It is not safe to merge these two switch instructions if they have a common
   // successor, and if that successor has a PHI node, and if *that* PHI node has
   // conflicting incoming values from the two switch blocks.
   BasicBlock *SI1BB = SI1->getParent();
   BasicBlock *SI2BB = SI2->getParent();
   SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
 
-  for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I)
-    if (SI1Succs.count(*I))
-      for (BasicBlock::iterator BBI = (*I)->begin();
+  for (BasicBlock *Succ : successors(SI2BB))
+    if (SI1Succs.count(Succ))
+      for (BasicBlock::iterator BBI = Succ->begin();
            isa<PHINode>(BBI); ++BBI) {
         PHINode *PN = cast<PHINode>(BBI);
         if (PN->getIncomingValueForBlock(SI1BB) !=
             PN->getIncomingValueForBlock(SI2BB))
           return false;
       }
 
   return true;
if (!(Cond->getOperand(0) == Ci2->getOperand(0) &&
         Cond->getOperand(1) == Ci2->getOperand(1)) &&
       !(Cond->getOperand(0) == Ci2->getOperand(1) &&
         Cond->getOperand(1) == Ci2->getOperand(0)))
     return false;
 
   BasicBlock *SI1BB = SI1->getParent();
   BasicBlock *SI2BB = SI2->getParent();
   SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
-  for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I)
-    if (SI1Succs.count(*I))
-      for (BasicBlock::iterator BBI = (*I)->begin();
+  for (BasicBlock *Succ : successors(SI2BB))
+    if (SI1Succs.count(Succ))
+      for (BasicBlock::iterator BBI = Succ->begin();
            isa<PHINode>(BBI); ++BBI) {
         PHINode *PN = cast<PHINode>(BBI);
         if (PN->getIncomingValueForBlock(SI1BB) != Cond ||
             !isa<ConstantInt>(PN->getIncomingValueForBlock(SI2BB)))
           return false;
         PhiNodes.push_back(PN);
       }
   return true;
if (ThisCases[i].Value == TIV) {
       break;
     }
 
   // If not handled by any explicit cases, it is handled by the default case.
   if (!TheRealDest) TheRealDest = ThisDef;
 
   // Remove PHI node entries for dead edges.
   BasicBlock *CheckEdge = TheRealDest;
-  for (succ_iterator SI = succ_begin(TIBB), e = succ_end(TIBB); SI != e; ++SI)
-    if (*SI != CheckEdge)
-      (*SI)->removePredecessor(TIBB);
+  for (BasicBlock *Succ : successors(TIBB))
+    if (Succ != CheckEdge)
+      Succ->removePredecessor(TIBB);
     else
       CheckEdge = nullptr;
 
   // Insert the new branch.
   Instruction *NI = Builder.CreateBr(TheRealDest);
   (void) NI;
 
   DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()

 }
 
 // isSafeToHoistInvoke - If we would need to insert a select that uses the
 // value of this invoke (comments in HoistThenElseCodeToIf explain why we
 // would need to do this), we can't hoist the invoke, as there is nowhere
 // to put the select in this case.
 static bool isSafeToHoistInvoke(BasicBlock *BB1, BasicBlock *BB2,
                                 Instruction *I1, Instruction *I2) {
-  for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) {
+  for (BasicBlock *Succ : successors(BB1)) {
     PHINode *PN;
-    for (BasicBlock::iterator BBI = SI->begin();
+    for (BasicBlock::iterator BBI = Succ->begin();
          (PN = dyn_cast<PHINode>(BBI)); ++BBI) {
       Value *BB1V = PN->getIncomingValueForBlock(BB1);
       Value *BB2V = PN->getIncomingValueForBlock(BB2);
       if (BB1V != BB2V && (BB1V==I1 || BB2V==I2)) {
         return false;
       }
     }
   }
static bool HoistThenElseCodeToIf(BranchInst *BI, const DataLayout *DL) {
 
   return true;
 
 HoistTerminator:
   // It may not be possible to hoist an invoke.
   if (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2))
     return Changed;
 
-  for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) {
+  for (BasicBlock *Succ : successors(BB1)) {
     PHINode *PN;
-    for (BasicBlock::iterator BBI = SI->begin();
+    for (BasicBlock::iterator BBI = Succ->begin();
          (PN = dyn_cast<PHINode>(BBI)); ++BBI) {
       Value *BB1V = PN->getIncomingValueForBlock(BB1);
       Value *BB2V = PN->getIncomingValueForBlock(BB2);
       if (BB1V == BB2V)
         continue;
 
       if (isa<ConstantExpr>(BB1V) && !isSafeToSpeculativelyExecute(BB1V, DL))
         return Changed;
HoistTerminator:
   }
 
   IRBuilder<true, NoFolder> Builder(NT);
   // Hoisting one of the terminators from our successor is a great thing.
   // Unfortunately, the successors of the if/else blocks may have PHI nodes in
   // them.  If they do, all PHI entries for BB1/BB2 must agree for all PHI
   // nodes, so we insert select instruction to compute the final result.
   std::map<std::pair<Value*,Value*>, SelectInst*> InsertedSelects;
-  for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) {
+  for (BasicBlock *Succ : successors(BB1)) {
     PHINode *PN;
-    for (BasicBlock::iterator BBI = SI->begin();
+    for (BasicBlock::iterator BBI = Succ->begin();
          (PN = dyn_cast<PHINode>(BBI)); ++BBI) {
       Value *BB1V = PN->getIncomingValueForBlock(BB1);
       Value *BB2V = PN->getIncomingValueForBlock(BB2);
       if (BB1V == BB2V) continue;
 
       // These values do not agree.  Insert a select instruction before NT
       // that determines the right value.
       SelectInst *&SI = InsertedSelects[std::make_pair(BB1V, BB2V)];
       if (!SI)
         SI = cast<SelectInst>
           (Builder.CreateSelect(BI->getCondition(), BB1V, BB2V,
                                 BB1V->getName()+"."+BB2V->getName()));
 
       // Make the PHI node use the select for all incoming values for BB1/BB2
       for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
         if (PN->getIncomingBlock(i) == BB1 || PN->getIncomingBlock(i) == BB2)
           PN->setIncomingValue(i, SI);
     }
   }
 
   // Update any PHI nodes in our new successors.
-  for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI)
-    AddPredecessorToBlock(*SI, BIParent, BB1);
+  for (BasicBlock *Succ : successors(BB1))
+    AddPredecessorToBlock(Succ, BIParent, BB1);
 
   EraseTerminatorInstAndDCECond(BI);
   return true;
 }
 
 /// SinkThenElseCodeToEnd - Given an unconditional branch that goes to BBEnd,
 /// check whether BBEnd has only two predecessors and the other predecessor
 /// ends with an unconditional branch. If it is true, sink any common code
if (CE->canTrap())
       return false;
 
   // Finally, don't infinitely unroll conditional loops.
   BasicBlock *TrueDest  = BI->getSuccessor(0);
   BasicBlock *FalseDest = (BI->isConditional()) ? BI->getSuccessor(1) : nullptr;
   if (TrueDest == BB || FalseDest == BB)
     return false;
 
-  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-    BasicBlock *PredBlock = *PI;
+  for (BasicBlock *PredBlock : predecessors(BB)) {
     BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator());
 
     // Check that we have two conditional branches.  If there is a PHI node in
     // the common successor, verify that the same value flows in from both
     // blocks.
     SmallVector<PHINode*, 4> PHIs;
     if (!PBI || PBI->isUnconditional() ||
         (BI->isConditional() &&
bool SimplifyCFGOpt::SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder) {
   BasicBlock::iterator I = LPInst, E = RI;
   while (++I != E)
     if (!isa<DbgInfoIntrinsic>(I))
       return false;
 
   // Turn all invokes that unwind here into calls and delete the basic block.
   bool InvokeRequiresTableEntry = false;
   bool Changed = false;
-  for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE;) {
-    InvokeInst *II = cast<InvokeInst>((*PI++)->getTerminator());
+  for (BasicBlock *Pred : predecessors(BB)) {
+    InvokeInst *II = cast<InvokeInst>(Pred->getTerminator());
 
     if (II->hasFnAttr(Attribute::UWTable)) {
       // Don't remove an `invoke' instruction if the ABI requires an entry into
       // the table.
       InvokeRequiresTableEntry = true;
       continue;
     }
 

 
 bool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder) {
   BasicBlock *BB = RI->getParent();
   if (!BB->getFirstNonPHIOrDbg()->isTerminator()) return false;
 
   // Find predecessors that end with branches.
   SmallVector<BasicBlock*, 8> UncondBranchPreds;
   SmallVector<BranchInst*, 8> CondBranchPreds;
-  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-    BasicBlock *P = *PI;
+  for (BasicBlock *P : predecessors(BB)) {
     TerminatorInst *PTI = P->getTerminator();
     if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) {
       if (BI->isUnconditional())
         UncondBranchPreds.push_back(P);
       else
         CondBranchPreds.push_back(BI);
     }
   }
bool SimplifyCFGOpt::SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
   // If this is a branch on a phi node in the current block, thread control
   // through this block if any PHI node entries are constants.
   if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition()))
     if (PN->getParent() == BI->getParent())
       if (FoldCondBranchOnPHI(BI, DL))
         return SimplifyCFG(BB, TTI, DL) | true;
 
   // Scan predecessor blocks for conditional branches.
-  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
-    if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
+  for (BasicBlock *Pred : predecessors(BB))
+    if (BranchInst *PBI = dyn_cast<BranchInst>(Pred->getTerminator()))
       if (PBI != BI && PBI->isConditional())
         if (SimplifyCondBranchToCondBranch(PBI, BI))
           return SimplifyCFG(BB, TTI, DL) | true;
 
   return false;
 }
 
 /// Check if passing a value to an instruction will cause undefined behavior.

lib/Transforms/Vectorize/LoopVectorize.cpp

if (OrigLoop->getHeader() == BB) {
     Value *C = ConstantInt::get(IntegerType::getInt1Ty(BB->getContext()), 1);
     return getVectorValue(C);
   }
 
   // This is the block mask. We OR all incoming edges, and with zero.
   Value *Zero = ConstantInt::get(IntegerType::getInt1Ty(BB->getContext()), 0);
   VectorParts BlockMask = getVectorValue(Zero);
 
-  // For each pred:
-  for (pred_iterator it = pred_begin(BB), e = pred_end(BB); it != e; ++it) {
-    VectorParts EM = createEdgeMask(*it, BB);
+  for (BasicBlock *Pred : predecessors(BB)) {
+    VectorParts EM = createEdgeMask(Pred, BB);
     for (unsigned part = 0; part < UF; ++part)
       BlockMask[part] = Builder.CreateOr(BlockMask[part], EM[part]);
   }
 
   return BlockMask;
 }
 
 void InnerLoopVectorizer::widenPHIInstruction(Instruction *PN,

tools/bugpoint/CrashDebugger.cpp

bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock*> &BBs) {
   outs() << ": ";
 
   // Loop over and delete any hack up any blocks that are not listed...
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
     for (Function::iterator BB = I->begin(), E = I->end(); BB != E; ++BB)
       if (!Blocks.count(BB) && BB->getTerminator()->getNumSuccessors()) {
         // Loop over all of the successors of this block, deleting any PHI nodes
         // that might include it.
-        for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
-          (*SI)->removePredecessor(BB);
+        for (BasicBlock *Succ : successors(BB))
+          Succ->removePredecessor(BB);
 
         TerminatorInst *BBTerm = BB->getTerminator();
         
         if (!BB->getTerminator()->getType()->isVoidTy())
           BBTerm->replaceAllUsesWith(Constant::getNullValue(BBTerm->getType()));
 
         // Replace the old terminator instruction.
         BB->getInstList().pop_back();

tools/llvm-diff/DifferenceEngine.cpp

class FunctionDifferenceEngine {
 
   /// The current mapping from old blocks to new blocks.
   DenseMap<BasicBlock*, BasicBlock*> Blocks;
 
   DenseSet<std::pair<Value*, Value*> > TentativeValues;
 
   unsigned getUnprocPredCount(BasicBlock *Block) const {
     unsigned Count = 0;
-    for (pred_iterator I = pred_begin(Block), E = pred_end(Block); I != E; ++I)
-      if (!Blocks.count(*I)) Count++;
+    for (BasicBlock *Pred : predecessors(Block))
+      if (!Blocks.count(Pred)) Count++;
     return Count;
   }
 
   typedef std::pair<BasicBlock*, BasicBlock*> BlockPair;
 
   /// A type which sorts a priority queue by the number of unprocessed
   /// predecessor blocks it has remaining.
   ///