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

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

Test Plan: All tests (make check-all) still pass.

Reviewers: dblaikie

Reviewed By: dblaikie

Subscribers: llvm-commits

Differential Revision: http://reviews.llvm.org/D4481

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213474 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/docs/ProgrammersManual.rst b/docs/ProgrammersManual.rst
index 46ec15f93a3236a65079e88254eb4f21704bee71..049e3720369b7ebbe956177821c68f14adb2a498 100644 (file)
--- a/docs/ProgrammersManual.rst
+++ b/docs/ProgrammersManual.rst
@@ -1854,12 +1854,11 @@ iterate over all predecessors of BB:
   #include "llvm/Support/CFG.h"
   BasicBlock *BB = ...;
 
   #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:
 
 
 .. _simplechanges:
 

diff --git a/include/llvm/IR/CFG.h b/include/llvm/IR/CFG.h
index c8be8bd1f2a7a3bd9d41ecf88216aa81747d7432..91cd84a15953a4d6cb47c501e243eb10bce2306b 100644 (file)
--- a/include/llvm/IR/CFG.h
+++ b/include/llvm/IR/CFG.h
@@ -93,6 +93,12 @@ 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 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));
+}

 
 
 
 
 
 


@@ -257,6 +263,12 @@ inline succ_iterator succ_end(BasicBlock *BB) {
 inline succ_const_iterator succ_end(const BasicBlock *BB) {
   return succ_const_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;
 
 template <typename T, typename U> struct isPodLike<SuccIterator<T, U> > {
   static const bool value = isPodLike<T>::value;

diff --git a/lib/Analysis/BranchProbabilityInfo.cpp b/lib/Analysis/BranchProbabilityInfo.cpp
index bbd87505952216d88b8cad5f042b36e03ecf7288..a1e4d8efebb799689931aec4756f9e9f6a89ee75 100644 (file)
--- a/lib/Analysis/BranchProbabilityInfo.cpp
+++ b/lib/Analysis/BranchProbabilityInfo.cpp
@@ -530,9 +530,8 @@ void BranchProbabilityInfo::print(raw_ostream &OS, const Module *) const {
   assert(LastF && "Cannot print prior to running over a function");
   for (Function::const_iterator BI = LastF->begin(), BE = LastF->end();
        BI != BE; ++BI) {
   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);

     }
   }
 }
     }
   }
 }


@@ -563,8 +562,7 @@ BasicBlock *BranchProbabilityInfo::getHotSucc(BasicBlock *BB) const {
   uint32_t MaxWeight = 0;
   BasicBlock *MaxSucc = nullptr;
 
   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;
 
     uint32_t Weight = getEdgeWeight(BB, Succ);
     uint32_t PrevSum = Sum;
 

diff --git a/lib/Analysis/Interval.cpp b/lib/Analysis/Interval.cpp
index e3e785ffc45fb3d15950b9e347da31c13eb95390..ca71cf3862879d67b5dba32f901e76331cbd8ec3 100644 (file)
--- a/lib/Analysis/Interval.cpp
+++ b/lib/Analysis/Interval.cpp
@@ -29,9 +29,8 @@ 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.
 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;
 }
       return true;
   return false;
 }

diff --git a/lib/Analysis/LazyValueInfo.cpp b/lib/Analysis/LazyValueInfo.cpp
index 9f919f7644a3fa62b0951b82a5639476e45218f8..a65480c2e407e8ea96652d1583645ebfec2cd902 100644 (file)
--- a/lib/Analysis/LazyValueInfo.cpp
+++ b/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;
   // 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;
     LVILatticeVal EdgeResult;

-    EdgesMissing |= !getEdgeValue(Val, *PI, BB, EdgeResult);
+    EdgesMissing |= !getEdgeValue(Val, Pred, BB, EdgeResult);

     if (EdgesMissing)
       continue;
 
     if (EdgesMissing)
       continue;
 

diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp
index 46c0eaabe1a3102e59ecc1b18f430800944b7dd4..a6d8b55c08f7cf3f5150c13296f175a836114e7d 100644 (file)
--- a/lib/Analysis/LoopInfo.cpp
+++ b/lib/Analysis/LoopInfo.cpp
@@ -336,9 +336,8 @@ bool Loop::hasDedicatedExits() const {
   SmallVector<BasicBlock *, 4> ExitBlocks;
   getExitBlocks(ExitBlocks);
   for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
   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;
         return false;
   // All the requirements are met.
   return true;


@@ -360,12 +359,12 @@ Loop::getUniqueExitBlocks(SmallVectorImpl<BasicBlock *> &ExitBlocks) const {
     BasicBlock *current = *BI;
     switchExitBlocks.clear();
 
     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 block is inside the loop then it is not a exit block.

-      if (contains(*I))
+      if (contains(Succ))

         continue;
 
         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
       BasicBlock *firstPred = *PI;
 
       // If current basic block is this exit block's first predecessor


@@ -379,17 +378,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) {
       // 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.
         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.end()) {

-        switchExitBlocks.push_back(*I);
-        ExitBlocks.push_back(*I);
+        switchExitBlocks.push_back(Succ);
+        ExitBlocks.push_back(Succ);

       }
     }
   }
       }
     }
   }

diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index 06dbde58c1084488ae087b9efbc0633394c0c11e..fd5b86b4634bb0e97ef9f712c0b94abde393fc6c 100644 (file)
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -4512,13 +4512,12 @@ ScalarEvolution::ComputeExitLimit(const Loop *L, BasicBlock *ExitingBlock) {
   // lead to the loop header.
   bool MustExecuteLoopHeader = true;
   BasicBlock *Exit = nullptr;
   // 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();
       if (Exit) // Multiple exit successors.
         return getCouldNotCompute();

-      Exit = *SI;
-    } else if (*SI != L->getHeader()) {
+      Exit = Succ;
+    } else if (Succ != L->getHeader()) {

       MustExecuteLoopHeader = false;
     }
 
       MustExecuteLoopHeader = false;
     }
 

diff --git a/lib/CodeGen/CodeGenPrepare.cpp b/lib/CodeGen/CodeGenPrepare.cpp
index d5039b2e8517cfdc523e91697ee25ae6a7f23f36..6f3ec1bda480ff72f9d73e79ebb10547a81bc061 100644 (file)
--- a/lib/CodeGen/CodeGenPrepare.cpp
+++ b/lib/CodeGen/CodeGenPrepare.cpp
@@ -453,8 +453,8 @@ void CodeGenPrepare::EliminateMostlyEmptyBlock(BasicBlock *BB) {
         for (unsigned i = 0, e = BBPN->getNumIncomingValues(); i != e; ++i)
           PN->addIncoming(InVal, BBPN->getIncomingBlock(i));
       } else {
         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);

       }
     }
   }
       }
     }
   }


@@ -977,11 +977,11 @@ bool CodeGenPrepare::DupRetToEnableTailCallOpts(BasicBlock *BB) {
     }
   } else {
     SmallPtrSet<BasicBlock*, 4> VisitedBBs;
     }
   } 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;
 
         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));
       BasicBlock::InstListType::reverse_iterator RI = InstList.rbegin();
       BasicBlock::InstListType::reverse_iterator RE = InstList.rend();
       do { ++RI; } while (RI != RE && isa<DbgInfoIntrinsic>(&*RI));

diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
index 57e22e21c3712454df7673ffab9e4b1b72b36b56..af7ecff9fc4b9537213c0eccfc1e849f8ba27bd2 100644 (file)
--- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -1052,9 +1052,8 @@ void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
 
     if (OptLevel != CodeGenOpt::None) {
       bool AllPredsVisited = true;
 
     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;
         }
           AllPredsVisited = false;
           break;
         }

diff --git a/lib/CodeGen/SjLjEHPrepare.cpp b/lib/CodeGen/SjLjEHPrepare.cpp
index b0950ded270aa9f6921280ee3d2dc73b598bfe55..1cfd4d255edf1b88a077b02f46f38bfd33e81bf6 100644 (file)
--- a/lib/CodeGen/SjLjEHPrepare.cpp
+++ b/lib/CodeGen/SjLjEHPrepare.cpp
@@ -142,8 +142,8 @@ static void MarkBlocksLiveIn(BasicBlock *BB,
   if (!LiveBBs.insert(BB))
     return; // already been here.
 
   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
 }
 
 /// substituteLPadValues - Substitute the values returned by the landingpad

diff --git a/lib/CodeGen/UnreachableBlockElim.cpp b/lib/CodeGen/UnreachableBlockElim.cpp
index 2e220820b9211d8c815a08f9663bd5dc3b0889bd..0476a1292f84ba3620701b563bcd38429e70f9d6 100644 (file)
--- a/lib/CodeGen/UnreachableBlockElim.cpp
+++ b/lib/CodeGen/UnreachableBlockElim.cpp
@@ -79,8 +79,8 @@ bool UnreachableBlockElim::runOnFunction(Function &F) {
         PN->replaceAllUsesWith(Constant::getNullValue(PN->getType()));
         BB->getInstList().pop_front();
       }
         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();
     }
 
       BB->dropAllReferences();
     }
 

diff --git a/lib/IR/BasicBlock.cpp b/lib/IR/BasicBlock.cpp
index ba07433103b6e16496213bbf8b1d0e7d0b339fed..8ddcf25fceda86932e66f5a5383e7528cfcbaa55 100644 (file)
--- a/lib/IR/BasicBlock.cpp
+++ b/lib/IR/BasicBlock.cpp
@@ -321,10 +321,9 @@ BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName) {
   // successors.  If there were PHI nodes in the successors, then they need to
   // know that incoming branches will be from New, not from Old.
   //
   // 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...
     // 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) {
     PHINode *PN;
     for (BasicBlock::iterator II = Successor->begin();
          (PN = dyn_cast<PHINode>(II)); ++II) {

diff --git a/lib/IR/Dominators.cpp b/lib/IR/Dominators.cpp
index d6649d6c7064bcc862abb2878b26ca524585da30..f45543a4e71f3569c7da713eeddfdc04aa3b589d 100644 (file)
--- a/lib/IR/Dominators.cpp
+++ b/lib/IR/Dominators.cpp
@@ -179,9 +179,7 @@ bool DominatorTree::dominates(const BasicBlockEdge &BBE,
   // 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.
   // 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 (BB == Start)
       continue;
 

diff --git a/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp
index 9cf911b51a4b4b339f37c96ebc92b266a441c4ee..5b7a34755742ba27e476c64af97f1554f500a5dc 100644 (file)
--- a/lib/IR/Verifier.cpp
+++ b/lib/IR/Verifier.cpp
@@ -2107,8 +2107,8 @@ void Verifier::visitLandingPadInst(LandingPadInst &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.
 
   // 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);
     Assert1(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
             "Block containing LandingPadInst must be jumped to "
             "only by the unwind edge of an invoke.", &LPI);

diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp
index f9de54a173d189aad211158be9c4e7eaa614c9bf..816fc291dc51c9165d65e39058e110b48b44fdf7 100644 (file)
--- a/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -473,8 +473,7 @@ bool ArgPromotion::isSafeToPromoteArgument(Argument *Arg,
     // 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.
     // 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)
       for (idf_ext_iterator<BasicBlock*, SmallPtrSet<BasicBlock*, 16> >
              I = idf_ext_begin(P, TranspBlocks),
              E = idf_ext_end(P, TranspBlocks); I != E; ++I)

diff --git a/lib/Transforms/IPO/LoopExtractor.cpp b/lib/Transforms/IPO/LoopExtractor.cpp
index 20414aa05b4dbf554be6bae3802f6e7873ac2f43..3f973c716fff16c444de8abff4454d32d944a9bf 100644 (file)
--- a/lib/Transforms/IPO/LoopExtractor.cpp
+++ b/lib/Transforms/IPO/LoopExtractor.cpp
@@ -229,9 +229,7 @@ void BlockExtractorPass::SplitLandingPadPreds(Function *F) {
     // 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;
     // 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;
       if (BB->isLandingPad() && BB != Parent &&
           isa<InvokeInst>(Parent->getTerminator())) {
         Split = true;

diff --git a/lib/Transforms/IPO/PartialInlining.cpp b/lib/Transforms/IPO/PartialInlining.cpp
index 76d6dfa8e881b205d66ea32e02b9e94c0fbc0499..5957e84ffab44835d347d7970be449c89c869681 100644 (file)
--- a/lib/Transforms/IPO/PartialInlining.cpp
+++ b/lib/Transforms/IPO/PartialInlining.cpp
@@ -58,13 +58,12 @@ Function* PartialInliner::unswitchFunction(Function* F) {
   BasicBlock* returnBlock = nullptr;
   BasicBlock* nonReturnBlock = nullptr;
   unsigned returnCount = 0;
   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
       returnCount++;
     } else

-      nonReturnBlock = *SI;
+      nonReturnBlock = Succ;

   
   if (returnCount != 1)
     return nullptr;
   
   if (returnCount != 1)
     return nullptr;

diff --git a/lib/Transforms/InstCombine/InstructionCombining.cpp b/lib/Transforms/InstCombine/InstructionCombining.cpp
index d3648e2d05053a8c891242051bc3feb7ff77ad9b..0e8518108da980c6a6bdafff016274fcaef5501b 100644 (file)
--- a/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -2718,8 +2718,8 @@ bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) {
       if (UserParent != BB) {
         bool UserIsSuccessor = false;
         // See if the user is one of our successors.
       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;
           }
             UserIsSuccessor = true;
             break;
           }

diff --git a/lib/Transforms/Scalar/DeadStoreElimination.cpp b/lib/Transforms/Scalar/DeadStoreElimination.cpp
index 3af8ee7546fbcab3dc8c20e0a047981f27960d3d..51e0bc289bb193592320075af035ae5e3928cc48 100644 (file)
--- a/lib/Transforms/Scalar/DeadStoreElimination.cpp
+++ b/lib/Transforms/Scalar/DeadStoreElimination.cpp
@@ -642,8 +642,7 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) {
 /// them to F.
 static void FindUnconditionalPreds(SmallVectorImpl<BasicBlock *> &Blocks,
                                    BasicBlock *BB, DominatorTree *DT) {
 /// 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)
     if (Pred == BB) continue;
     TerminatorInst *PredTI = Pred->getTerminator();
     if (PredTI->getNumSuccessors() != 1)

diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
index 106eba099ca05504f06675b32a044cb99bcc5fcd..3ed7e3e5a3e05dbd302816d218da6e81f282d6d8 100644 (file)
--- a/lib/Transforms/Scalar/GVN.cpp
+++ b/lib/Transforms/Scalar/GVN.cpp
@@ -1555,9 +1555,7 @@ bool GVN::PerformLoadPRE(LoadInst *LI, AvailValInBlkVect &ValuesPerBlock,
     FullyAvailableBlocks[UnavailableBlocks[i]] = false;
 
   SmallVector<BasicBlock *, 4> CriticalEdgePred;
     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 (IsValueFullyAvailableInBlock(Pred, FullyAvailableBlocks, 0)) {
       continue;
     }


@@ -2483,9 +2481,7 @@ bool GVN::performPRE(Function &F) {
       BasicBlock *PREPred = nullptr;
       predMap.clear();
 
       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.
         // We're not interested in PRE where the block is its
         // own predecessor, or in blocks with predecessors
         // that are not reachable.


@@ -2713,14 +2709,13 @@ void GVN::addDeadBlock(BasicBlock *BB) {
     for (SmallVectorImpl<BasicBlock *>::iterator I = Dom.begin(),
            E = Dom.end(); I != E; I++) {
       BasicBlock *B = *I;
     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;
         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;
           }
             AllPredDead = false;
             break;
           }

diff --git a/lib/Transforms/Scalar/JumpThreading.cpp b/lib/Transforms/Scalar/JumpThreading.cpp
index 21f80385cf46940fe4b54c969ac6d9ce99eba9d0..d9b6d560f098aad193b3852bd964dfc20e6ee466 100644 (file)
--- a/lib/Transforms/Scalar/JumpThreading.cpp
+++ b/lib/Transforms/Scalar/JumpThreading.cpp
@@ -353,8 +353,8 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, PredValueInfo &Result,
 
   // If V is a constant, then it is known in all predecessors.
   if (Constant *KC = getKnownConstant(V, Preference)) {
 
   // 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;
   }
 
     return true;
   }


@@ -377,8 +377,7 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, PredValueInfo &Result,
     // "X < 4" and "X < 3" is known true but "X < 4" itself is not available.
     // Perhaps getConstantOnEdge should be smart enough to do this?
 
     // "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 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);


@@ -532,8 +531,7 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, PredValueInfo &Result,
           cast<Instruction>(Cmp->getOperand(0))->getParent() != BB) {
         Constant *RHSCst = cast<Constant>(Cmp->getOperand(1));
 
           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 =
           // 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 =


@@ -606,8 +604,8 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, PredValueInfo &Result,
   // 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)) {
   // 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();
   }
 
   return !Result.empty();


@@ -899,10 +897,7 @@ bool JumpThreading::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
 
   // 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.
 
   // 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;
     // If we already scanned this predecessor, skip it.
     if (!PredsScanned.insert(PredBB))
       continue;


@@ -952,9 +947,7 @@ bool JumpThreading::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
       AvailablePredSet.insert(AvailablePreds[i].first);
 
     // Add all the unavailable predecessors to the PredsToSplit list.
       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 the predecessor is an indirect goto, we can't split the edge.
       if (isa<IndirectBrInst>(P->getTerminator()))
         return false;

diff --git a/lib/Transforms/Scalar/LoopInstSimplify.cpp b/lib/Transforms/Scalar/LoopInstSimplify.cpp
index ab1a9393c526c7c05377945ea4364405544a42ea..657038eeca7d58d3ff4eb3bdc9847f4f7f10cce8 100644 (file)
--- a/lib/Transforms/Scalar/LoopInstSimplify.cpp
+++ b/lib/Transforms/Scalar/LoopInstSimplify.cpp
@@ -145,9 +145,7 @@ bool LoopInstSimplify::runOnLoop(Loop *L, LPPassManager &LPM) {
       // 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.
       // 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;
 
         if (!Visited.insert(SuccBB))
           continue;
 

diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp
index 977c53a3bc6327046fb53d31c9eaf8bddfef26b9..68bd4b82959c12fa2822142af2746b87a95d5dcc 100644 (file)
--- a/lib/Transforms/Scalar/LoopUnswitch.cpp
+++ b/lib/Transforms/Scalar/LoopUnswitch.cpp
@@ -515,9 +515,9 @@ static bool isTrivialLoopExitBlockHelper(Loop *L, BasicBlock *BB,
   }
 
   // Otherwise, this is an unvisited intra-loop node.  Check all successors.
   }
 
   // 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.
     // 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;
   }
 
       return false;
   }
 


@@ -861,9 +861,7 @@ void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
       PHINode *PN = PHINode::Create(LPad->getType(), 0, "",
                                     ExitSucc->getFirstInsertionPt());
 
       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);
         LandingPadInst *LPI = BB->getLandingPadInst();
         LPI->replaceAllUsesWith(PN);
         PN->addIncoming(LPI, BB);

diff --git a/lib/Transforms/Scalar/SampleProfile.cpp b/lib/Transforms/Scalar/SampleProfile.cpp
index 73c97ffeef4f98fdf65558665f589fcaa8eb8b18..8e3583a1237854f7c05a31d33a46d846b872aa9b 100644 (file)
--- a/lib/Transforms/Scalar/SampleProfile.cpp
+++ b/lib/Transforms/Scalar/SampleProfile.cpp
@@ -865,8 +865,7 @@ void SampleFunctionProfile::buildEdges(Function &F) {
     SmallPtrSet<BasicBlock *, 16> Visited;
     if (!Predecessors[B1].empty())
       llvm_unreachable("Found a stale predecessors list in a basic block.");
     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);
     }
       if (Visited.insert(B2))
         Predecessors[B1].push_back(B2);
     }


@@ -875,8 +874,7 @@ void SampleFunctionProfile::buildEdges(Function &F) {
     Visited.clear();
     if (!Successors[B1].empty())
       llvm_unreachable("Found a stale successors list in a basic block.");
     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);
     }
       if (Visited.insert(B2))
         Successors[B1].push_back(B2);
     }

diff --git a/lib/Transforms/Scalar/Sink.cpp b/lib/Transforms/Scalar/Sink.cpp
index 7348c45c5d37be8d65b4dc48e62fcfeab33bd25c..2f7a9f9a65cf8505659d61e3a6b4a4a3aab4ce81 100644 (file)
--- a/lib/Transforms/Scalar/Sink.cpp
+++ b/lib/Transforms/Scalar/Sink.cpp
@@ -258,10 +258,11 @@ bool Sinking::SinkInstruction(Instruction *Inst,
 
   // If no suitable postdominator was found, look at all the successors and
   // decide which one we should sink to, if any.
 
   // 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 we couldn't find a block to sink to, ignore this instruction.

diff --git a/lib/Transforms/Scalar/StructurizeCFG.cpp b/lib/Transforms/Scalar/StructurizeCFG.cpp
index b9673ed655e004242ab08442f3dea66ccc0d1621..d2206e380c1eaf338d64f9a90c59431417df247d 100644 (file)
--- a/lib/Transforms/Scalar/StructurizeCFG.cpp
+++ b/lib/Transforms/Scalar/StructurizeCFG.cpp
@@ -365,41 +365,39 @@ void StructurizeCFG::gatherPredicates(RegionNode *N) {
   BBPredicates &Pred = Predicates[BB];
   BBPredicates &LPred = LoopPreds[BB];
 
   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
     // Ignore it if it's a branch from outside into our region entry

-    if (!ParentRegion->contains(*PI))
+    if (!ParentRegion->contains(Predecessor))

       continue;
 
       continue;
 

-    Region *R = RI->getRegionFor(*PI);
+    Region *R = RI->getRegionFor(Predecessor);

     if (R == ParentRegion) {
 
       // It's a top level block in our region
     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;
 
       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) &&
           // 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[Other] = BoolFalse;

-              Pred[*PI] = BoolTrue;
+              Pred[Predecessor] = BoolTrue;

               continue;
             }
           }
               continue;
             }
           }

-          Pred[*PI] = buildCondition(Term, i, false);
+          Pred[Predecessor] = buildCondition(Term, i, false);

 
         } else {
           // Back edge
 
         } else {
           // Back edge

-          LPred[*PI] = buildCondition(Term, i, true);
+          LPred[Predecessor] = buildCondition(Term, i, true);

         }
       }
 
         }
       }
 


@@ -574,11 +572,8 @@ void StructurizeCFG::killTerminator(BasicBlock *BB) {
   if (!Term)
     return;
 
   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();
 }
 
   Term->eraseFromParent();
 }


@@ -592,10 +587,7 @@ void StructurizeCFG::changeExit(RegionNode *Node, BasicBlock *NewExit,
     BasicBlock *Dominator = nullptr;
 
     // Find all the edges from the sub region to the exit
     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;
 
       if (!SubRegion->contains(BB))
         continue;
 

diff --git a/lib/Transforms/Scalar/TailRecursionElimination.cpp b/lib/Transforms/Scalar/TailRecursionElimination.cpp
index 05b9892470bb8dddebe9fd1af2ec7e8d0b5b85dd..d9280ac6c9c11084785a59316401606d6fa83a3c 100644 (file)
--- a/lib/Transforms/Scalar/TailRecursionElimination.cpp
+++ b/lib/Transforms/Scalar/TailRecursionElimination.cpp
@@ -335,7 +335,7 @@ bool TailCallElim::markTails(Function &F, bool &AllCallsAreTailCalls) {
       }
     }
 
       }
     }
 

-    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;
       auto &State = Visited[SuccBB];
       if (State < Escaped) {
         State = Escaped;


@@ -807,8 +807,7 @@ bool TailCallElim::FoldReturnAndProcessPred(BasicBlock *BB,
   // predecessors and perform TRC there. Look for predecessors that end
   // in unconditional branch and recursive call(s).
   SmallVector<BranchInst*, 8> UncondBranchPreds;
   // 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())
     TerminatorInst *PTI = Pred->getTerminator();
     if (BranchInst *BI = dyn_cast<BranchInst>(PTI))
       if (BI->isUnconditional())

diff --git a/lib/Transforms/Utils/BasicBlockUtils.cpp b/lib/Transforms/Utils/BasicBlockUtils.cpp
index 602e8ba55107a073109533d06c3dca0223d76504..5af417cd936a8c9be2c2de7feb20ef4e103836f5 100644 (file)
--- a/lib/Transforms/Utils/BasicBlockUtils.cpp
+++ b/lib/Transforms/Utils/BasicBlockUtils.cpp
@@ -549,14 +549,11 @@ void llvm::SplitLandingPadPredecessors(BasicBlock *OrigBB,
 
   // Move the remaining edges from OrigBB to point to NewBB2.
   SmallVector<BasicBlock*, 8> NewBB2Preds;
 
   // 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);
     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;
   }
 
   BasicBlock *NewBB2 = nullptr;

diff --git a/lib/Transforms/Utils/BreakCriticalEdges.cpp b/lib/Transforms/Utils/BreakCriticalEdges.cpp
index 80bd516375146afa2f25bff4a22dfb4e4d9bcd1e..dc12f9770461dc17043f4e504b0dbecc9ab1f817 100644 (file)
--- a/lib/Transforms/Utils/BreakCriticalEdges.cpp
+++ b/lib/Transforms/Utils/BreakCriticalEdges.cpp
@@ -233,9 +233,7 @@ BasicBlock *llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum,
       if (PN->getIncomingBlock(i) != NewBB)
         OtherPreds.push_back(PN->getIncomingBlock(i));
   } else {
       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);
     }
       if (P != NewBB)
         OtherPreds.push_back(P);
     }


@@ -321,9 +319,7 @@ BasicBlock *llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum,
         // the predecessor must be directly in TIL, not in a subloop, or again
         // LoopSimplify doesn't hold.
         SmallVector<BasicBlock *, 4> LoopPreds;
         // 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) {
           if (P == NewBB)
             continue; // The new block is known.
           if (LI->getLoopFor(P) != TIL) {

diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp
index 5c8f20d5f884161767c0c01cd2b1146c252e1ffe..f148ea17481ed7ca694d9baf76653260c138cd67 100644 (file)
--- a/lib/Transforms/Utils/CloneFunction.cpp
+++ b/lib/Transforms/Utils/CloneFunction.cpp
@@ -514,9 +514,8 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
       assert(NumPreds < PN->getNumIncomingValues());
       // Count how many times each predecessor comes to this block.
       std::map<BasicBlock*, unsigned> PredCount;
       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)
       
       // Figure out how many entries to remove from each PHI.
       for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)

diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp
index e70a7d6e76c6e5f123334a9cf8497e604f8fe153..d7445ef65b66ec5186fbe966ae3a33f1701a3a2e 100644 (file)
--- a/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/lib/Transforms/Utils/CodeExtractor.cpp
@@ -91,9 +91,8 @@ static SetVector<BasicBlock *> buildExtractionBlockSet(IteratorT BBBegin,
   for (SetVector<BasicBlock *>::iterator I = std::next(Result.begin()),
                                          E = Result.end();
        I != E; ++I)
   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
              "No blocks in this region may have entries from outside the region"
              " except for the first block!");
 #endif


@@ -721,9 +720,9 @@ Function *CodeExtractor::extractCodeRegion() {
   SmallPtrSet<BasicBlock *, 1> ExitBlocks;
   for (SetVector<BasicBlock *>::iterator I = Blocks.begin(), E = Blocks.end();
        I != E; ++I)
   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.
   NumExitBlocks = ExitBlocks.size();
 
   // Construct new function based on inputs/outputs & add allocas for all defs.

diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index a5e443fcf46b165b04c1f3d4ead8acdfc0dee345..113a2ae7584b0e907bb633297780291fb625d4b3 100644 (file)
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -1129,8 +1129,8 @@ 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.
   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.
 
   // 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.


@@ -1236,9 +1236,9 @@ static bool markAliveBlocks(BasicBlock *BB,
     }
 
     Changed |= ConstantFoldTerminator(BB, 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;
 }
   } while (!Worklist.empty());
   return Changed;
 }


@@ -1263,9 +1263,9 @@ bool llvm::removeUnreachableBlocks(Function &F) {
     if (Reachable.count(BB))
       continue;
 
     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();
   }
 
     BB->dropAllReferences();
   }
 

diff --git a/lib/Transforms/Utils/LoopSimplify.cpp b/lib/Transforms/Utils/LoopSimplify.cpp
index ef422914b6b2b318b846a7a62d87a8f47f5d854c..faab772585504d114fc3f1df7453f1c72529f843 100644 (file)
--- a/lib/Transforms/Utils/LoopSimplify.cpp
+++ b/lib/Transforms/Utils/LoopSimplify.cpp
@@ -114,9 +114,7 @@ BasicBlock *llvm::InsertPreheaderForLoop(Loop *L, Pass *PP) {
 
   // Compute the set of predecessors of the loop that are not in the loop.
   SmallVector<BasicBlock*, 8> OutsideBlocks;
 
   // 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
     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


@@ -158,8 +156,7 @@ BasicBlock *llvm::InsertPreheaderForLoop(Loop *L, Pass *PP) {
 /// the loop.
 static BasicBlock *rewriteLoopExitBlock(Loop *L, BasicBlock *Exit, Pass *PP) {
   SmallVector<BasicBlock*, 8> LoopBlocks;
 /// 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;
     if (L->contains(P)) {
       // Don't do this if the loop is exited via an indirect branch.
       if (isa<IndirectBrInst>(P->getTerminator())) return nullptr;


@@ -199,10 +196,8 @@ static void addBlockAndPredsToSet(BasicBlock *InputBB, BasicBlock *StopBlock,
     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
     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);
         Worklist.push_back(WBB);

-      }

   } while (!Worklist.empty());
 }
 
   } while (!Worklist.empty());
 }
 


@@ -316,8 +311,7 @@ static Loop *separateNestedLoop(Loop *L, BasicBlock *Preheader,
   // Determine which blocks should stay in L and which should be moved out to
   // the Outer loop now.
   std::set<BasicBlock*> BlocksInL;
   // 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);
   }
     if (DT->dominates(Header, P))
       addBlockAndPredsToSet(P, Header, BlocksInL);
   }


@@ -371,9 +365,7 @@ static BasicBlock *insertUniqueBackedgeBlock(Loop *L, BasicBlock *Preheader,
 
   // Figure out which basic blocks contain back-edges to the loop header.
   std::vector<BasicBlock*> BackedgeBlocks;
 
   // 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;
     // Indirectbr edges cannot be split, so we must fail if we find one.
     if (isa<IndirectBrInst>(P->getTerminator()))
       return nullptr;


@@ -488,9 +480,7 @@ ReprocessLoop:
     if (*BB == L->getHeader()) continue;
 
     SmallPtrSet<BasicBlock*, 4> BadPreds;
     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);
     }
       if (!L->contains(P))
         BadPreds.insert(P);
     }


@@ -503,8 +493,8 @@ ReprocessLoop:
                    << (*I)->getName() << "\n");
 
       // Inform each successor of each dead pred.
                    << (*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()));
       // Zap the dead pred's terminator and replace it with unreachable.
       TerminatorInst *TI = (*I)->getTerminator();
        TI->replaceAllUsesWith(UndefValue::get(TI->getType()));


@@ -561,11 +551,10 @@ ReprocessLoop:
   for (SmallSetVector<BasicBlock *, 8>::iterator I = ExitBlockSet.begin(),
          E = ExitBlockSet.end(); I != E; ++I) {
     BasicBlock *ExitBlock = *I;
   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.
       // 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;
         if (rewriteLoopExitBlock(L, ExitBlock, PP)) {
           ++NumInserted;
           Changed = true;

diff --git a/lib/Transforms/Utils/LoopUnroll.cpp b/lib/Transforms/Utils/LoopUnroll.cpp
index ab1c25a75e262be4e42839f30944dbb406c23172..3b0e813072de918380c8a1b4a184f701cf7a534a 100644 (file)
--- a/lib/Transforms/Utils/LoopUnroll.cpp
+++ b/lib/Transforms/Utils/LoopUnroll.cpp
@@ -328,11 +328,10 @@ bool llvm::UnrollLoop(Loop *L, unsigned Count, unsigned TripCount,
       L->addBasicBlockToLoop(New, LI->getBase());
 
       // Add phi entries for newly created values to all exit blocks.
       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;
           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);
              PHINode *phi = dyn_cast<PHINode>(BBI); ++BBI) {
           Value *Incoming = phi->getIncomingValueForBlock(*BB);
           ValueToValueMapTy::iterator It = LastValueMap.find(Incoming);


@@ -414,11 +413,10 @@ bool llvm::UnrollLoop(Loop *L, unsigned Count, unsigned TripCount,
       // Remove phi operands at this loop exit
       if (Dest != LoopExit) {
         BasicBlock *BB = Latches[i];
       // 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;
             continue;

-          for (BasicBlock::iterator BBI = (*SI)->begin();
+          for (BasicBlock::iterator BBI = Succ->begin();

                PHINode *Phi = dyn_cast<PHINode>(BBI); ++BBI) {
             Phi->removeIncomingValue(BB, false);
           }
                PHINode *Phi = dyn_cast<PHINode>(BBI); ++BBI) {
             Phi->removeIncomingValue(BB, false);
           }

diff --git a/lib/Transforms/Utils/LoopUnrollRuntime.cpp b/lib/Transforms/Utils/LoopUnrollRuntime.cpp
index a96c46ad63e0d62d658dc51e49b30b2b221881d8..ce420ee4bf0b607ff8db6602c4c8a4f14d8efabc 100644 (file)
--- a/lib/Transforms/Utils/LoopUnrollRuntime.cpp
+++ b/lib/Transforms/Utils/LoopUnrollRuntime.cpp
@@ -66,9 +66,8 @@ static void ConnectProlog(Loop *L, Value *TripCount, unsigned Count,
   // 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.
   // 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
          PHINode *PN = dyn_cast<PHINode>(BBI); ++BBI) {
 
       // Add a new PHI node to the prolog end block and add the

diff --git a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
index 06d73feb1cc875a1cf1d0490020925eaaa534c22..a3da98923142859c7398abb17b5ed6df1978b467 100644 (file)
--- a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
+++ b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
@@ -822,9 +822,7 @@ void PromoteMem2Reg::ComputeLiveInBlocks(
     // 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.
     // 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;
       // The value is not live into a predecessor if it defines the value.
       if (DefBlocks.count(P))
         continue;


@@ -885,9 +883,8 @@ void PromoteMem2Reg::DetermineInsertionPoint(AllocaInst *AI, unsigned AllocaNum,
       DomTreeNode *Node = Worklist.pop_back_val();
       BasicBlock *BB = Node->getBlock();
 
       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.
 
         // Quickly skip all CFG edges that are also dominator tree edges instead
         // of catching them below.

diff --git a/lib/Transforms/Utils/SSAUpdater.cpp b/lib/Transforms/Utils/SSAUpdater.cpp
index 3fcb789bd8425a681d2f3cf21b815aa1d5c8727d..67d06d1ef64ec9a38eba6922bd3608259d92d517 100644 (file)
--- a/lib/Transforms/Utils/SSAUpdater.cpp
+++ b/lib/Transforms/Utils/SSAUpdater.cpp
@@ -110,8 +110,7 @@ Value *SSAUpdater::GetValueInMiddleOfBlock(BasicBlock *BB) {
     }
   } else {
     bool isFirstPred = true;
     }
   } 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));
 
       Value *PredVal = GetValueAtEndOfBlock(PredBB);
       PredValues.push_back(std::make_pair(PredBB, PredVal));
 


@@ -248,8 +247,7 @@ public:
       for (unsigned PI = 0, E = SomePhi->getNumIncomingValues(); PI != E; ++PI)
         Preds->push_back(SomePhi->getIncomingBlock(PI));
     } else {
       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));

     }
   }
 
     }
   }
 

diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp
index 960b198f36bdf93c16a1b0cc57aa0e64b3b8a8f9..4e589cc6ab894a49cae5b9e1b86f385f16a6f779 100644 (file)
--- a/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -130,9 +130,9 @@ static bool SafeToMergeTerminators(TerminatorInst *SI1, TerminatorInst *SI2) {
   BasicBlock *SI2BB = SI2->getParent();
   SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
 
   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) !=
            isa<PHINode>(BBI); ++BBI) {
         PHINode *PN = cast<PHINode>(BBI);
         if (PN->getIncomingValueForBlock(SI1BB) !=


@@ -171,9 +171,9 @@ static bool isProfitableToFoldUnconditional(BranchInst *SI1,
   BasicBlock *SI1BB = SI1->getParent();
   BasicBlock *SI2BB = SI2->getParent();
   SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
   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<PHINode>(BBI); ++BBI) {
         PHINode *PN = cast<PHINode>(BBI);
         if (PN->getIncomingValueForBlock(SI1BB) != Cond ||


@@ -683,9 +683,9 @@ SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
 
   // Remove PHI node entries for dead edges.
   BasicBlock *CheckEdge = TheRealDest;
 
   // 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;
 
     else
       CheckEdge = nullptr;
 


@@ -981,9 +981,9 @@ bool SimplifyCFGOpt::FoldValueComparisonIntoPredecessors(TerminatorInst *TI,
 // to put the select in this case.
 static bool isSafeToHoistInvoke(BasicBlock *BB1, BasicBlock *BB2,
                                 Instruction *I1, Instruction *I2) {
 // 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;
     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);
          (PN = dyn_cast<PHINode>(BBI)); ++BBI) {
       Value *BB1V = PN->getIncomingValueForBlock(BB1);
       Value *BB2V = PN->getIncomingValueForBlock(BB2);


@@ -1063,9 +1063,9 @@ HoistTerminator:
   if (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2))
     return Changed;
 
   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;
     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);
          (PN = dyn_cast<PHINode>(BBI)); ++BBI) {
       Value *BB1V = PN->getIncomingValueForBlock(BB1);
       Value *BB2V = PN->getIncomingValueForBlock(BB2);


@@ -1094,9 +1094,9 @@ HoistTerminator:
   // 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;
   // 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;
     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);
          (PN = dyn_cast<PHINode>(BBI)); ++BBI) {
       Value *BB1V = PN->getIncomingValueForBlock(BB1);
       Value *BB2V = PN->getIncomingValueForBlock(BB2);


@@ -1118,8 +1118,8 @@ HoistTerminator:
   }
 
   // Update any PHI nodes in our new successors.
   }
 
   // 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;
 
   EraseTerminatorInstAndDCECond(BI);
   return true;


@@ -2051,8 +2051,7 @@ bool llvm::FoldBranchToCommonDest(BranchInst *BI, const DataLayout *DL) {
   if (TrueDest == BB || FalseDest == BB)
     return false;
 
   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
     BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator());
 
     // Check that we have two conditional branches.  If there is a PHI node in


@@ -2885,8 +2884,8 @@ bool SimplifyCFGOpt::SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder) {
   // Turn all invokes that unwind here into calls and delete the basic block.
   bool InvokeRequiresTableEntry = false;
   bool Changed = 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
 
     if (II->hasFnAttr(Attribute::UWTable)) {
       // Don't remove an `invoke' instruction if the ABI requires an entry into


@@ -2933,8 +2932,7 @@ bool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder) {
   // Find predecessors that end with branches.
   SmallVector<BasicBlock*, 8> UncondBranchPreds;
   SmallVector<BranchInst*, 8> CondBranchPreds;
   // 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())
     TerminatorInst *PTI = P->getTerminator();
     if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) {
       if (BI->isUnconditional())


@@ -4100,8 +4098,8 @@ bool SimplifyCFGOpt::SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
         return SimplifyCFG(BB, TTI, DL) | true;
 
   // Scan predecessor blocks for conditional branches.
         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;
       if (PBI != BI && PBI->isConditional())
         if (SimplifyCondBranchToCondBranch(PBI, BI))
           return SimplifyCFG(BB, TTI, DL) | true;

diff --git a/lib/Transforms/Vectorize/LoopVectorize.cpp b/lib/Transforms/Vectorize/LoopVectorize.cpp
index 909de67c4a581db61198b2216343da74bb23a670..adf241d9b0854cecdf5174cbb77c918f19028ff9 100644 (file)
--- a/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -2934,9 +2934,8 @@ InnerLoopVectorizer::createBlockInMask(BasicBlock *BB) {
   Value *Zero = ConstantInt::get(IntegerType::getInt1Ty(BB->getContext()), 0);
   VectorParts BlockMask = getVectorValue(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]);
   }
     for (unsigned part = 0; part < UF; ++part)
       BlockMask[part] = Builder.CreateOr(BlockMask[part], EM[part]);
   }

diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp
index 8bd61b3c0964baa0dd662571af4575e5dec4adbd..a3f3b4491c5fe51cb789da9e66dc1c11e97a1920 100644 (file)
--- a/tools/bugpoint/CrashDebugger.cpp
+++ b/tools/bugpoint/CrashDebugger.cpp
@@ -292,8 +292,8 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock*> &BBs) {
       if (!Blocks.count(BB) && BB->getTerminator()->getNumSuccessors()) {
         // Loop over all of the successors of this block, deleting any PHI nodes
         // that might include it.
       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();
         
 
         TerminatorInst *BBTerm = BB->getTerminator();
         

diff --git a/tools/llvm-diff/DifferenceEngine.cpp b/tools/llvm-diff/DifferenceEngine.cpp
index 7d379ef5dc41cf7048da7ec15cde97220e4dc051..f8e957fa506f042b36d313ffd1386af3b1dee751 100644 (file)
--- a/tools/llvm-diff/DifferenceEngine.cpp
+++ b/tools/llvm-diff/DifferenceEngine.cpp
@@ -125,8 +125,8 @@ class FunctionDifferenceEngine {
 
   unsigned getUnprocPredCount(BasicBlock *Block) const {
     unsigned Count = 0;
 
   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;
   }
 
     return Count;
   }