[llvm] r213562 - Revert "[C++11] Add predecessors(BasicBlock *) / successors(BasicBlock *) iterator ranges."
Duncan P. N. Exon Smith
dexonsmith at apple.com
Mon Jul 21 10:06:52 PDT 2014
Author: dexonsmith
Date: Mon Jul 21 12:06:51 2014
New Revision: 213562
URL: http://llvm.org/viewvc/llvm-project?rev=213562&view=rev
Log:
Revert "[C++11] Add predecessors(BasicBlock *) / successors(BasicBlock *) iterator ranges."
This reverts commit r213474 (and r213475), which causes a miscompile on
a stage2 LTO build. I'll reply on the list in a moment.
Modified:
llvm/trunk/docs/ProgrammersManual.rst
llvm/trunk/include/llvm/IR/CFG.h
llvm/trunk/lib/Analysis/BranchProbabilityInfo.cpp
llvm/trunk/lib/Analysis/Interval.cpp
llvm/trunk/lib/Analysis/LazyValueInfo.cpp
llvm/trunk/lib/Analysis/LoopInfo.cpp
llvm/trunk/lib/Analysis/ScalarEvolution.cpp
llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp
llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
llvm/trunk/lib/CodeGen/SjLjEHPrepare.cpp
llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp
llvm/trunk/lib/IR/BasicBlock.cpp
llvm/trunk/lib/IR/Dominators.cpp
llvm/trunk/lib/IR/Verifier.cpp
llvm/trunk/lib/Transforms/IPO/ArgumentPromotion.cpp
llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp
llvm/trunk/lib/Transforms/IPO/PartialInlining.cpp
llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp
llvm/trunk/lib/Transforms/Scalar/GVN.cpp
llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp
llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp
llvm/trunk/lib/Transforms/Scalar/SampleProfile.cpp
llvm/trunk/lib/Transforms/Scalar/Sink.cpp
llvm/trunk/lib/Transforms/Scalar/StructurizeCFG.cpp
llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp
llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp
llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp
llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp
llvm/trunk/lib/Transforms/Utils/Local.cpp
llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp
llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp
llvm/trunk/lib/Transforms/Utils/LoopUnrollRuntime.cpp
llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
llvm/trunk/lib/Transforms/Utils/SSAUpdater.cpp
llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
llvm/trunk/tools/bugpoint/CrashDebugger.cpp
llvm/trunk/tools/llvm-diff/DifferenceEngine.cpp
Modified: llvm/trunk/docs/ProgrammersManual.rst
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/ProgrammersManual.rst?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/docs/ProgrammersManual.rst (original)
+++ llvm/trunk/docs/ProgrammersManual.rst Mon Jul 21 12:06:51 2014
@@ -1854,11 +1854,12 @@ iterate over all predecessors of BB:
#include "llvm/Support/CFG.h"
BasicBlock *BB = ...;
- for (BasicBlock *Pred : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *Pred = *PI;
// ...
}
-Similarly, to iterate over successors use ``successors``.
+Similarly, to iterate over successors use ``succ_iterator/succ_begin/succ_end``.
.. _simplechanges:
Modified: llvm/trunk/include/llvm/IR/CFG.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/CFG.h?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/include/llvm/IR/CFG.h (original)
+++ llvm/trunk/include/llvm/IR/CFG.h Mon Jul 21 12:06:51 2014
@@ -93,12 +93,6 @@ inline pred_iterator pred_end(BasicBlock
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));
-}
@@ -263,12 +257,6 @@ inline succ_iterator succ_end(BasicBlock
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;
Modified: llvm/trunk/lib/Analysis/BranchProbabilityInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BranchProbabilityInfo.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/BranchProbabilityInfo.cpp (original)
+++ llvm/trunk/lib/Analysis/BranchProbabilityInfo.cpp Mon Jul 21 12:06:51 2014
@@ -528,9 +528,13 @@ void BranchProbabilityInfo::print(raw_os
// We print the probabilities from the last function the analysis ran over,
// or the function it is currently running over.
assert(LastF && "Cannot print prior to running over a function");
- for (const BasicBlock &BB : *LastF)
- for (const BasicBlock *Succ : successors(&BB))
- printEdgeProbability(OS << " ", &BB, Succ);
+ for (Function::const_iterator BI = LastF->begin(), BE = LastF->end();
+ BI != BE; ++BI) {
+ for (succ_const_iterator SI = succ_begin(BI), SE = succ_end(BI);
+ SI != SE; ++SI) {
+ printEdgeProbability(OS << " ", BI, *SI);
+ }
+ }
}
uint32_t BranchProbabilityInfo::getSumForBlock(const BasicBlock *BB) const {
@@ -559,7 +563,8 @@ BasicBlock *BranchProbabilityInfo::getHo
uint32_t MaxWeight = 0;
BasicBlock *MaxSucc = nullptr;
- for (BasicBlock *Succ : successors(BB)) {
+ for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
+ BasicBlock *Succ = *I;
uint32_t Weight = getEdgeWeight(BB, Succ);
uint32_t PrevSum = Sum;
Modified: llvm/trunk/lib/Analysis/Interval.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/Interval.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/Interval.cpp (original)
+++ llvm/trunk/lib/Analysis/Interval.cpp Mon Jul 21 12:06:51 2014
@@ -29,8 +29,9 @@ using namespace llvm;
bool Interval::isLoop() const {
// There is a loop in this interval iff one of the predecessors of the header
// node lives in the interval.
- for (BasicBlock *Pred : predecessors(HeaderNode))
- if (contains(Pred))
+ for (::pred_iterator I = ::pred_begin(HeaderNode), E = ::pred_end(HeaderNode);
+ I != E; ++I)
+ if (contains(*I))
return true;
return false;
}
Modified: llvm/trunk/lib/Analysis/LazyValueInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/LazyValueInfo.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/LazyValueInfo.cpp (original)
+++ llvm/trunk/lib/Analysis/LazyValueInfo.cpp Mon Jul 21 12:06:51 2014
@@ -625,9 +625,9 @@ bool LazyValueInfoCache::solveBlockValue
// Loop over all of our predecessors, merging what we know from them into
// result.
bool EdgesMissing = false;
- for (BasicBlock *Pred : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
LVILatticeVal EdgeResult;
- EdgesMissing |= !getEdgeValue(Val, Pred, BB, EdgeResult);
+ EdgesMissing |= !getEdgeValue(Val, *PI, BB, EdgeResult);
if (EdgesMissing)
continue;
Modified: llvm/trunk/lib/Analysis/LoopInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/LoopInfo.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/LoopInfo.cpp (original)
+++ llvm/trunk/lib/Analysis/LoopInfo.cpp Mon Jul 21 12:06:51 2014
@@ -336,8 +336,9 @@ bool Loop::hasDedicatedExits() const {
SmallVector<BasicBlock *, 4> ExitBlocks;
getExitBlocks(ExitBlocks);
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
- for (BasicBlock *Pred : predecessors(ExitBlocks[i]))
- if (!contains(Pred))
+ for (pred_iterator PI = pred_begin(ExitBlocks[i]),
+ PE = pred_end(ExitBlocks[i]); PI != PE; ++PI)
+ if (!contains(*PI))
return false;
// All the requirements are met.
return true;
@@ -359,12 +360,12 @@ Loop::getUniqueExitBlocks(SmallVectorImp
BasicBlock *current = *BI;
switchExitBlocks.clear();
- for (BasicBlock *Succ : successors(*BI)) {
+ for (succ_iterator I = succ_begin(*BI), E = succ_end(*BI); I != E; ++I) {
// If block is inside the loop then it is not a exit block.
- if (contains(Succ))
+ if (contains(*I))
continue;
- pred_iterator PI = pred_begin(Succ);
+ pred_iterator PI = pred_begin(*I);
BasicBlock *firstPred = *PI;
// If current basic block is this exit block's first predecessor
@@ -378,17 +379,17 @@ Loop::getUniqueExitBlocks(SmallVectorImp
// then it is possible that there are multiple edges from current block
// to one exit block.
if (std::distance(succ_begin(current), succ_end(current)) <= 2) {
- ExitBlocks.push_back(Succ);
+ ExitBlocks.push_back(*I);
continue;
}
// In case of multiple edges from current block to exit block, collect
// only one edge in ExitBlocks. Use switchExitBlocks to keep track of
// duplicate edges.
- if (std::find(switchExitBlocks.begin(), switchExitBlocks.end(), Succ)
+ if (std::find(switchExitBlocks.begin(), switchExitBlocks.end(), *I)
== switchExitBlocks.end()) {
- switchExitBlocks.push_back(Succ);
- ExitBlocks.push_back(Succ);
+ switchExitBlocks.push_back(*I);
+ ExitBlocks.push_back(*I);
}
}
}
Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
+++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Mon Jul 21 12:06:51 2014
@@ -4512,12 +4512,13 @@ ScalarEvolution::ComputeExitLimit(const
// lead to the loop header.
bool MustExecuteLoopHeader = true;
BasicBlock *Exit = nullptr;
- for (BasicBlock *Succ : successors(ExitingBlock))
- if (!L->contains(Succ)) {
+ for (succ_iterator SI = succ_begin(ExitingBlock), SE = succ_end(ExitingBlock);
+ SI != SE; ++SI)
+ if (!L->contains(*SI)) {
if (Exit) // Multiple exit successors.
return getCouldNotCompute();
- Exit = Succ;
- } else if (Succ != L->getHeader()) {
+ Exit = *SI;
+ } else if (*SI != L->getHeader()) {
MustExecuteLoopHeader = false;
}
Modified: llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp (original)
+++ llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp Mon Jul 21 12:06:51 2014
@@ -453,8 +453,8 @@ void CodeGenPrepare::EliminateMostlyEmpt
for (unsigned i = 0, e = BBPN->getNumIncomingValues(); i != e; ++i)
PN->addIncoming(InVal, BBPN->getIncomingBlock(i));
} else {
- for (BasicBlock *Pred : predecessors(BB))
- PN->addIncoming(InVal, Pred);
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
+ PN->addIncoming(InVal, *PI);
}
}
}
@@ -977,11 +977,11 @@ bool CodeGenPrepare::DupRetToEnableTailC
}
} else {
SmallPtrSet<BasicBlock*, 4> VisitedBBs;
- for (BasicBlock *Pred : predecessors(BB)) {
- if (!VisitedBBs.insert(Pred))
+ for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI) {
+ if (!VisitedBBs.insert(*PI))
continue;
- BasicBlock::InstListType &InstList = Pred->getInstList();
+ BasicBlock::InstListType &InstList = (*PI)->getInstList();
BasicBlock::InstListType::reverse_iterator RI = InstList.rbegin();
BasicBlock::InstListType::reverse_iterator RE = InstList.rend();
do { ++RI; } while (RI != RE && isa<DbgInfoIntrinsic>(&*RI));
Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp (original)
+++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp Mon Jul 21 12:06:51 2014
@@ -1052,8 +1052,9 @@ void SelectionDAGISel::SelectAllBasicBlo
if (OptLevel != CodeGenOpt::None) {
bool AllPredsVisited = true;
- for (const BasicBlock *Pred : predecessors(LLVMBB)) {
- if (!FuncInfo->VisitedBBs.count(Pred)) {
+ for (const_pred_iterator PI = pred_begin(LLVMBB), PE = pred_end(LLVMBB);
+ PI != PE; ++PI) {
+ if (!FuncInfo->VisitedBBs.count(*PI)) {
AllPredsVisited = false;
break;
}
Modified: llvm/trunk/lib/CodeGen/SjLjEHPrepare.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SjLjEHPrepare.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/SjLjEHPrepare.cpp (original)
+++ llvm/trunk/lib/CodeGen/SjLjEHPrepare.cpp Mon Jul 21 12:06:51 2014
@@ -142,8 +142,8 @@ static void MarkBlocksLiveIn(BasicBlock
if (!LiveBBs.insert(BB))
return; // already been here.
- for (BasicBlock *Pred : predecessors(BB))
- MarkBlocksLiveIn(Pred, LiveBBs);
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
+ MarkBlocksLiveIn(*PI, LiveBBs);
}
/// substituteLPadValues - Substitute the values returned by the landingpad
Modified: llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp (original)
+++ llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp Mon Jul 21 12:06:51 2014
@@ -79,8 +79,8 @@ bool UnreachableBlockElim::runOnFunction
PN->replaceAllUsesWith(Constant::getNullValue(PN->getType()));
BB->getInstList().pop_front();
}
- for (BasicBlock *S : successors(BB))
- S->removePredecessor(BB);
+ for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
+ (*SI)->removePredecessor(BB);
BB->dropAllReferences();
}
Modified: llvm/trunk/lib/IR/BasicBlock.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/BasicBlock.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/IR/BasicBlock.cpp (original)
+++ llvm/trunk/lib/IR/BasicBlock.cpp Mon Jul 21 12:06:51 2014
@@ -321,9 +321,10 @@ BasicBlock *BasicBlock::splitBasicBlock(
// 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 (BasicBlock *Successor : successors(New)) {
+ for (succ_iterator I = succ_begin(New), E = succ_end(New); I != E; ++I) {
// 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) {
Modified: llvm/trunk/lib/IR/Dominators.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Dominators.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/IR/Dominators.cpp (original)
+++ llvm/trunk/lib/IR/Dominators.cpp Mon Jul 21 12:06:51 2014
@@ -179,7 +179,9 @@ bool DominatorTree::dominates(const Basi
// 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 BasicBlock *BB : predecessors(End)) {
+ for (const_pred_iterator PI = pred_begin(End), E = pred_end(End);
+ PI != E; ++PI) {
+ const BasicBlock *BB = *PI;
if (BB == Start)
continue;
Modified: llvm/trunk/lib/IR/Verifier.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Verifier.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/IR/Verifier.cpp (original)
+++ llvm/trunk/lib/IR/Verifier.cpp Mon Jul 21 12:06:51 2014
@@ -2107,8 +2107,8 @@ void Verifier::visitLandingPadInst(Landi
// 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 (BasicBlock *Pred : predecessors(BB)) {
- const InvokeInst *II = dyn_cast<InvokeInst>(Pred->getTerminator());
+ for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
+ const InvokeInst *II = dyn_cast<InvokeInst>((*I)->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);
Modified: llvm/trunk/lib/Transforms/IPO/ArgumentPromotion.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/ArgumentPromotion.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/IPO/ArgumentPromotion.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/ArgumentPromotion.cpp Mon Jul 21 12:06:51 2014
@@ -473,7 +473,8 @@ bool ArgPromotion::isSafeToPromoteArgume
// 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 (BasicBlock *P : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *P = *PI;
for (idf_ext_iterator<BasicBlock*, SmallPtrSet<BasicBlock*, 16> >
I = idf_ext_begin(P, TranspBlocks),
E = idf_ext_end(P, TranspBlocks); I != E; ++I)
Modified: llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp Mon Jul 21 12:06:51 2014
@@ -229,7 +229,9 @@ void BlockExtractorPass::SplitLandingPad
// 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 (BasicBlock *BB : predecessors(LPad)) {
+ for (pred_iterator
+ PI = pred_begin(LPad), PE = pred_end(LPad); PI != PE; ++PI) {
+ BasicBlock *BB = *PI;
if (BB->isLandingPad() && BB != Parent &&
isa<InvokeInst>(Parent->getTerminator())) {
Split = true;
Modified: llvm/trunk/lib/Transforms/IPO/PartialInlining.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/PartialInlining.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/IPO/PartialInlining.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/PartialInlining.cpp Mon Jul 21 12:06:51 2014
@@ -58,12 +58,13 @@ Function* PartialInliner::unswitchFuncti
BasicBlock* returnBlock = nullptr;
BasicBlock* nonReturnBlock = nullptr;
unsigned returnCount = 0;
- for (BasicBlock *Succ : successors(entryBlock))
- if (isa<ReturnInst>(Succ->getTerminator())) {
- returnBlock = Succ;
+ for (succ_iterator SI = succ_begin(entryBlock), SE = succ_end(entryBlock);
+ SI != SE; ++SI)
+ if (isa<ReturnInst>((*SI)->getTerminator())) {
+ returnBlock = *SI;
returnCount++;
} else
- nonReturnBlock = Succ;
+ nonReturnBlock = *SI;
if (returnCount != 1)
return nullptr;
Modified: llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp (original)
+++ llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp Mon Jul 21 12:06:51 2014
@@ -2718,8 +2718,8 @@ bool InstCombiner::DoOneIteration(Functi
if (UserParent != BB) {
bool UserIsSuccessor = false;
// See if the user is one of our successors.
- for (BasicBlock *Succ : successors(BB))
- if (Succ == UserParent) {
+ for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
+ if (*SI == UserParent) {
UserIsSuccessor = true;
break;
}
Modified: llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp Mon Jul 21 12:06:51 2014
@@ -642,7 +642,8 @@ bool DSE::runOnBasicBlock(BasicBlock &BB
/// them to F.
static void FindUnconditionalPreds(SmallVectorImpl<BasicBlock *> &Blocks,
BasicBlock *BB, DominatorTree *DT) {
- for (BasicBlock *Pred : predecessors(BB)) {
+ for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
+ BasicBlock *Pred = *I;
if (Pred == BB) continue;
TerminatorInst *PredTI = Pred->getTerminator();
if (PredTI->getNumSuccessors() != 1)
Modified: llvm/trunk/lib/Transforms/Scalar/GVN.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/GVN.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/GVN.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/GVN.cpp Mon Jul 21 12:06:51 2014
@@ -1555,7 +1555,9 @@ bool GVN::PerformLoadPRE(LoadInst *LI, A
FullyAvailableBlocks[UnavailableBlocks[i]] = false;
SmallVector<BasicBlock *, 4> CriticalEdgePred;
- for (BasicBlock *Pred : predecessors(LoadBB)) {
+ for (pred_iterator PI = pred_begin(LoadBB), E = pred_end(LoadBB);
+ PI != E; ++PI) {
+ BasicBlock *Pred = *PI;
if (IsValueFullyAvailableInBlock(Pred, FullyAvailableBlocks, 0)) {
continue;
}
@@ -2481,7 +2483,9 @@ bool GVN::performPRE(Function &F) {
BasicBlock *PREPred = nullptr;
predMap.clear();
- for (BasicBlock *P : predecessors(CurrentBlock)) {
+ for (pred_iterator PI = pred_begin(CurrentBlock),
+ PE = pred_end(CurrentBlock); PI != PE; ++PI) {
+ BasicBlock *P = *PI;
// We're not interested in PRE where the block is its
// own predecessor, or in blocks with predecessors
// that are not reachable.
@@ -2709,13 +2713,14 @@ void GVN::addDeadBlock(BasicBlock *BB) {
for (SmallVectorImpl<BasicBlock *>::iterator I = Dom.begin(),
E = Dom.end(); I != E; I++) {
BasicBlock *B = *I;
- for (BasicBlock *S : successors(B)) {
+ for (succ_iterator SI = succ_begin(B), SE = succ_end(B); SI != SE; SI++) {
+ BasicBlock *S = *SI;
if (DeadBlocks.count(S))
continue;
bool AllPredDead = true;
- for (BasicBlock *Pred : predecessors(S))
- if (!DeadBlocks.count(Pred)) {
+ for (pred_iterator PI = pred_begin(S), PE = pred_end(S); PI != PE; PI++)
+ if (!DeadBlocks.count(*PI)) {
AllPredDead = false;
break;
}
Modified: llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp Mon Jul 21 12:06:51 2014
@@ -353,8 +353,8 @@ ComputeValueKnownInPredecessors(Value *V
// If V is a constant, then it is known in all predecessors.
if (Constant *KC = getKnownConstant(V, Preference)) {
- for (BasicBlock *Pred : predecessors(BB))
- Result.push_back(std::make_pair(KC, Pred));
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
+ Result.push_back(std::make_pair(KC, *PI));
return true;
}
@@ -377,7 +377,8 @@ ComputeValueKnownInPredecessors(Value *V
// "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 (BasicBlock *P : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *P = *PI;
// 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);
@@ -531,7 +532,8 @@ ComputeValueKnownInPredecessors(Value *V
cast<Instruction>(Cmp->getOperand(0))->getParent() != BB) {
Constant *RHSCst = cast<Constant>(Cmp->getOperand(1));
- for (BasicBlock *P : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB);PI != E; ++PI){
+ BasicBlock *P = *PI;
// 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 =
@@ -604,8 +606,8 @@ ComputeValueKnownInPredecessors(Value *V
// 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 (BasicBlock *Pred : predecessors(BB))
- Result.push_back(std::make_pair(KC, Pred));
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
+ Result.push_back(std::make_pair(KC, *PI));
}
return !Result.empty();
@@ -897,7 +899,10 @@ bool JumpThreading::SimplifyPartiallyRed
// 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 (BasicBlock *PredBB : predecessors(LoadBB)) {
+ for (pred_iterator PI = pred_begin(LoadBB), PE = pred_end(LoadBB);
+ PI != PE; ++PI) {
+ BasicBlock *PredBB = *PI;
+
// If we already scanned this predecessor, skip it.
if (!PredsScanned.insert(PredBB))
continue;
@@ -947,7 +952,9 @@ bool JumpThreading::SimplifyPartiallyRed
AvailablePredSet.insert(AvailablePreds[i].first);
// Add all the unavailable predecessors to the PredsToSplit list.
- for (BasicBlock *P : predecessors(LoadBB)) {
+ for (pred_iterator PI = pred_begin(LoadBB), PE = pred_end(LoadBB);
+ PI != PE; ++PI) {
+ BasicBlock *P = *PI;
// If the predecessor is an indirect goto, we can't split the edge.
if (isa<IndirectBrInst>(P->getTerminator()))
return false;
Modified: llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp Mon Jul 21 12:06:51 2014
@@ -145,7 +145,9 @@ bool LoopInstSimplify::runOnLoop(Loop *L
// 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 (BasicBlock *SuccBB : successors(BB)) {
+ for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE;
+ ++SI) {
+ BasicBlock *SuccBB = *SI;
if (!Visited.insert(SuccBB))
continue;
Modified: llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp Mon Jul 21 12:06:51 2014
@@ -515,9 +515,9 @@ static bool isTrivialLoopExitBlockHelper
}
// Otherwise, this is an unvisited intra-loop node. Check all successors.
- for (BasicBlock *Succ : successors(BB)) {
+ for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI) {
// Check to see if the successor is a trivial loop exit.
- if (!isTrivialLoopExitBlockHelper(L, Succ, ExitBB, Visited))
+ if (!isTrivialLoopExitBlockHelper(L, *SI, ExitBB, Visited))
return false;
}
@@ -861,7 +861,9 @@ void LoopUnswitch::UnswitchNontrivialCon
PHINode *PN = PHINode::Create(LPad->getType(), 0, "",
ExitSucc->getFirstInsertionPt());
- for (BasicBlock *BB : predecessors(ExitSucc)) {
+ for (pred_iterator I = pred_begin(ExitSucc), E = pred_end(ExitSucc);
+ I != E; ++I) {
+ BasicBlock *BB = *I;
LandingPadInst *LPI = BB->getLandingPadInst();
LPI->replaceAllUsesWith(PN);
PN->addIncoming(LPI, BB);
Modified: llvm/trunk/lib/Transforms/Scalar/SampleProfile.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SampleProfile.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/SampleProfile.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/SampleProfile.cpp Mon Jul 21 12:06:51 2014
@@ -865,7 +865,8 @@ void SampleFunctionProfile::buildEdges(F
SmallPtrSet<BasicBlock *, 16> Visited;
if (!Predecessors[B1].empty())
llvm_unreachable("Found a stale predecessors list in a basic block.");
- for (BasicBlock *B2 : predecessors(B1)) {
+ for (pred_iterator PI = pred_begin(B1), PE = pred_end(B1); PI != PE; ++PI) {
+ BasicBlock *B2 = *PI;
if (Visited.insert(B2))
Predecessors[B1].push_back(B2);
}
@@ -874,7 +875,8 @@ void SampleFunctionProfile::buildEdges(F
Visited.clear();
if (!Successors[B1].empty())
llvm_unreachable("Found a stale successors list in a basic block.");
- for (BasicBlock *B2 : successors(B1)) {
+ for (succ_iterator SI = succ_begin(B1), SE = succ_end(B1); SI != SE; ++SI) {
+ BasicBlock *B2 = *SI;
if (Visited.insert(B2))
Successors[B1].push_back(B2);
}
Modified: llvm/trunk/lib/Transforms/Scalar/Sink.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/Sink.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/Sink.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/Sink.cpp Mon Jul 21 12:06:51 2014
@@ -258,11 +258,10 @@ bool Sinking::SinkInstruction(Instructio
// If no suitable postdominator was found, look at all the successors and
// decide which one we should sink to, if any.
- for (BasicBlock *Succ : successors(Inst->getParent())) {
- if (SuccToSinkTo)
- break;
- if (IsAcceptableTarget(Inst, Succ))
- SuccToSinkTo = Succ;
+ for (succ_iterator I = succ_begin(Inst->getParent()),
+ E = succ_end(Inst->getParent()); I != E && !SuccToSinkTo; ++I) {
+ if (IsAcceptableTarget(Inst, *I))
+ SuccToSinkTo = *I;
}
// If we couldn't find a block to sink to, ignore this instruction.
Modified: llvm/trunk/lib/Transforms/Scalar/StructurizeCFG.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/StructurizeCFG.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/StructurizeCFG.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/StructurizeCFG.cpp Mon Jul 21 12:06:51 2014
@@ -365,39 +365,41 @@ void StructurizeCFG::gatherPredicates(Re
BBPredicates &Pred = Predicates[BB];
BBPredicates &LPred = LoopPreds[BB];
- for (BasicBlock *Predecessor : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
+ PI != PE; ++PI) {
+
// Ignore it if it's a branch from outside into our region entry
- if (!ParentRegion->contains(Predecessor))
+ if (!ParentRegion->contains(*PI))
continue;
- Region *R = RI->getRegionFor(Predecessor);
+ Region *R = RI->getRegionFor(*PI);
if (R == ParentRegion) {
// It's a top level block in our region
- BranchInst *Term = cast<BranchInst>(Predecessor->getTerminator());
+ BranchInst *Term = cast<BranchInst>((*PI)->getTerminator());
for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) {
BasicBlock *Succ = Term->getSuccessor(i);
if (Succ != BB)
continue;
- if (Visited.count(Predecessor)) {
+ if (Visited.count(*PI)) {
// 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(Predecessor)) {
+ !Pred.count(Other) && !Pred.count(*PI)) {
Pred[Other] = BoolFalse;
- Pred[Predecessor] = BoolTrue;
+ Pred[*PI] = BoolTrue;
continue;
}
}
- Pred[Predecessor] = buildCondition(Term, i, false);
+ Pred[*PI] = buildCondition(Term, i, false);
} else {
// Back edge
- LPred[Predecessor] = buildCondition(Term, i, true);
+ LPred[*PI] = buildCondition(Term, i, true);
}
}
@@ -572,8 +574,11 @@ void StructurizeCFG::killTerminator(Basi
if (!Term)
return;
- for (BasicBlock *Succ : successors(BB))
- delPhiValues(BB, Succ);
+ for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB);
+ SI != SE; ++SI) {
+
+ delPhiValues(BB, *SI);
+ }
Term->eraseFromParent();
}
@@ -587,7 +592,10 @@ void StructurizeCFG::changeExit(RegionNo
BasicBlock *Dominator = nullptr;
// Find all the edges from the sub region to the exit
- for (BasicBlock *BB : predecessors(OldExit)) {
+ for (pred_iterator I = pred_begin(OldExit), E = pred_end(OldExit);
+ I != E;) {
+
+ BasicBlock *BB = *I++;
if (!SubRegion->contains(BB))
continue;
Modified: llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/TailRecursionElimination.cpp Mon Jul 21 12:06:51 2014
@@ -335,7 +335,7 @@ bool TailCallElim::markTails(Function &F
}
}
- for (auto *SuccBB : successors(BB)) {
+ for (auto *SuccBB : make_range(succ_begin(BB), succ_end(BB))) {
auto &State = Visited[SuccBB];
if (State < Escaped) {
State = Escaped;
@@ -807,7 +807,8 @@ bool TailCallElim::FoldReturnAndProcessP
// predecessors and perform TRC there. Look for predecessors that end
// in unconditional branch and recursive call(s).
SmallVector<BranchInst*, 8> UncondBranchPreds;
- for (BasicBlock *Pred : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *Pred = *PI;
TerminatorInst *PTI = Pred->getTerminator();
if (BranchInst *BI = dyn_cast<BranchInst>(PTI))
if (BI->isUnconditional())
Modified: llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp Mon Jul 21 12:06:51 2014
@@ -549,11 +549,14 @@ void llvm::SplitLandingPadPredecessors(B
// Move the remaining edges from OrigBB to point to NewBB2.
SmallVector<BasicBlock*, 8> NewBB2Preds;
- for (BasicBlock *Pred : predecessors(OrigBB)) {
+ for (pred_iterator i = pred_begin(OrigBB), e = pred_end(OrigBB);
+ i != e; ) {
+ BasicBlock *Pred = *i++;
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;
Modified: llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp Mon Jul 21 12:06:51 2014
@@ -233,7 +233,9 @@ BasicBlock *llvm::SplitCriticalEdge(Term
if (PN->getIncomingBlock(i) != NewBB)
OtherPreds.push_back(PN->getIncomingBlock(i));
} else {
- for (BasicBlock *P : predecessors(DestBB)) {
+ for (pred_iterator I = pred_begin(DestBB), E = pred_end(DestBB);
+ I != E; ++I) {
+ BasicBlock *P = *I;
if (P != NewBB)
OtherPreds.push_back(P);
}
@@ -319,7 +321,9 @@ BasicBlock *llvm::SplitCriticalEdge(Term
// the predecessor must be directly in TIL, not in a subloop, or again
// LoopSimplify doesn't hold.
SmallVector<BasicBlock *, 4> LoopPreds;
- for (BasicBlock *P : predecessors(DestBB)) {
+ for (pred_iterator I = pred_begin(DestBB), E = pred_end(DestBB); I != E;
+ ++I) {
+ BasicBlock *P = *I;
if (P == NewBB)
continue; // The new block is known.
if (LI->getLoopFor(P) != TIL) {
Modified: llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp Mon Jul 21 12:06:51 2014
@@ -514,8 +514,9 @@ void llvm::CloneAndPruneFunctionInto(Fun
assert(NumPreds < PN->getNumIncomingValues());
// Count how many times each predecessor comes to this block.
std::map<BasicBlock*, unsigned> PredCount;
- for (BasicBlock *Pred : predecessors(NewBB))
- --PredCount[Pred];
+ for (pred_iterator PI = pred_begin(NewBB), E = pred_end(NewBB);
+ PI != E; ++PI)
+ --PredCount[*PI];
// Figure out how many entries to remove from each PHI.
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
Modified: llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp Mon Jul 21 12:06:51 2014
@@ -91,8 +91,9 @@ static SetVector<BasicBlock *> buildExtr
for (SetVector<BasicBlock *>::iterator I = std::next(Result.begin()),
E = Result.end();
I != E; ++I)
- for (BasicBlock *Pred : predecessors(*I))
- assert(Result.count(Pred) &&
+ for (pred_iterator PI = pred_begin(*I), PE = pred_end(*I);
+ PI != PE; ++PI)
+ assert(Result.count(*PI) &&
"No blocks in this region may have entries from outside the region"
" except for the first block!");
#endif
@@ -720,9 +721,9 @@ Function *CodeExtractor::extractCodeRegi
SmallPtrSet<BasicBlock *, 1> ExitBlocks;
for (SetVector<BasicBlock *>::iterator I = Blocks.begin(), E = Blocks.end();
I != E; ++I)
- for (BasicBlock *Succ : successors(*I))
- if (!Blocks.count(Succ))
- ExitBlocks.insert(Succ);
+ for (succ_iterator SI = succ_begin(*I), SE = succ_end(*I); SI != SE; ++SI)
+ if (!Blocks.count(*SI))
+ ExitBlocks.insert(*SI);
NumExitBlocks = ExitBlocks.size();
// Construct new function based on inputs/outputs & add allocas for all defs.
Modified: llvm/trunk/lib/Transforms/Utils/Local.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Local.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/Local.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/Local.cpp Mon Jul 21 12:06:51 2014
@@ -1129,8 +1129,8 @@ static void changeToUnreachable(Instruct
BasicBlock *BB = I->getParent();
// Loop over all of the successors, removing BB's entry from any PHI
// nodes.
- for (BasicBlock *Succ : successors(BB))
- Succ->removePredecessor(BB);
+ for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
+ (*SI)->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.
@@ -1236,9 +1236,9 @@ static bool markAliveBlocks(BasicBlock *
}
Changed |= ConstantFoldTerminator(BB, true);
- for (BasicBlock *Succ : successors(BB))
- if (Reachable.insert(Succ))
- Worklist.push_back(Succ);
+ for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
+ if (Reachable.insert(*SI))
+ Worklist.push_back(*SI);
} while (!Worklist.empty());
return Changed;
}
@@ -1263,9 +1263,9 @@ bool llvm::removeUnreachableBlocks(Funct
if (Reachable.count(BB))
continue;
- for (BasicBlock *Succ : successors(BB))
- if (Reachable.count(Succ))
- Succ->removePredecessor(BB);
+ for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
+ if (Reachable.count(*SI))
+ (*SI)->removePredecessor(BB);
BB->dropAllReferences();
}
Modified: llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp Mon Jul 21 12:06:51 2014
@@ -114,7 +114,9 @@ BasicBlock *llvm::InsertPreheaderForLoop
// Compute the set of predecessors of the loop that are not in the loop.
SmallVector<BasicBlock*, 8> OutsideBlocks;
- for (BasicBlock *P : predecessors(Header)) {
+ for (pred_iterator PI = pred_begin(Header), PE = pred_end(Header);
+ PI != PE; ++PI) {
+ BasicBlock *P = *PI;
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
@@ -156,7 +158,8 @@ BasicBlock *llvm::InsertPreheaderForLoop
/// the loop.
static BasicBlock *rewriteLoopExitBlock(Loop *L, BasicBlock *Exit, Pass *PP) {
SmallVector<BasicBlock*, 8> LoopBlocks;
- for (BasicBlock *P : predecessors(Exit)) {
+ for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit); I != E; ++I) {
+ BasicBlock *P = *I;
if (L->contains(P)) {
// Don't do this if the loop is exited via an indirect branch.
if (isa<IndirectBrInst>(P->getTerminator())) return nullptr;
@@ -196,8 +199,10 @@ static void addBlockAndPredsToSet(BasicB
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 (BasicBlock *WBB : predecessors(BB))
+ for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
+ BasicBlock *WBB = *I;
Worklist.push_back(WBB);
+ }
} while (!Worklist.empty());
}
@@ -311,7 +316,8 @@ static Loop *separateNestedLoop(Loop *L,
// Determine which blocks should stay in L and which should be moved out to
// the Outer loop now.
std::set<BasicBlock*> BlocksInL;
- for (BasicBlock *P : predecessors(Header)) {
+ for (pred_iterator PI=pred_begin(Header), E = pred_end(Header); PI!=E; ++PI) {
+ BasicBlock *P = *PI;
if (DT->dominates(Header, P))
addBlockAndPredsToSet(P, Header, BlocksInL);
}
@@ -365,7 +371,9 @@ static BasicBlock *insertUniqueBackedgeB
// Figure out which basic blocks contain back-edges to the loop header.
std::vector<BasicBlock*> BackedgeBlocks;
- for (BasicBlock *P : predecessors(Header)) {
+ for (pred_iterator I = pred_begin(Header), E = pred_end(Header); I != E; ++I){
+ BasicBlock *P = *I;
+
// Indirectbr edges cannot be split, so we must fail if we find one.
if (isa<IndirectBrInst>(P->getTerminator()))
return nullptr;
@@ -480,7 +488,9 @@ ReprocessLoop:
if (*BB == L->getHeader()) continue;
SmallPtrSet<BasicBlock*, 4> BadPreds;
- for (BasicBlock *P : predecessors(*BB)) {
+ for (pred_iterator PI = pred_begin(*BB),
+ PE = pred_end(*BB); PI != PE; ++PI) {
+ BasicBlock *P = *PI;
if (!L->contains(P))
BadPreds.insert(P);
}
@@ -493,8 +503,8 @@ ReprocessLoop:
<< (*I)->getName() << "\n");
// Inform each successor of each dead pred.
- for (BasicBlock *Succ : successors(*I))
- Succ->removePredecessor(*I);
+ for (succ_iterator SI = succ_begin(*I), SE = succ_end(*I); SI != SE; ++SI)
+ (*SI)->removePredecessor(*I);
// Zap the dead pred's terminator and replace it with unreachable.
TerminatorInst *TI = (*I)->getTerminator();
TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
@@ -551,10 +561,11 @@ ReprocessLoop:
for (SmallSetVector<BasicBlock *, 8>::iterator I = ExitBlockSet.begin(),
E = ExitBlockSet.end(); I != E; ++I) {
BasicBlock *ExitBlock = *I;
- for (BasicBlock *Pred : predecessors(ExitBlock))
+ for (pred_iterator PI = pred_begin(ExitBlock), PE = pred_end(ExitBlock);
+ PI != PE; ++PI)
// Must be exactly this loop: no subloops, parent loops, or non-loop preds
// allowed.
- if (!L->contains(Pred)) {
+ if (!L->contains(*PI)) {
if (rewriteLoopExitBlock(L, ExitBlock, PP)) {
++NumInserted;
Changed = true;
Modified: llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp Mon Jul 21 12:06:51 2014
@@ -328,10 +328,11 @@ bool llvm::UnrollLoop(Loop *L, unsigned
L->addBasicBlockToLoop(New, LI->getBase());
// Add phi entries for newly created values to all exit blocks.
- for (BasicBlock *Succ : successors(*BB)) {
- if (L->contains(Succ))
+ for (succ_iterator SI = succ_begin(*BB), SE = succ_end(*BB);
+ SI != SE; ++SI) {
+ if (L->contains(*SI))
continue;
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (BasicBlock::iterator BBI = (*SI)->begin();
PHINode *phi = dyn_cast<PHINode>(BBI); ++BBI) {
Value *Incoming = phi->getIncomingValueForBlock(*BB);
ValueToValueMapTy::iterator It = LastValueMap.find(Incoming);
@@ -413,10 +414,11 @@ bool llvm::UnrollLoop(Loop *L, unsigned
// Remove phi operands at this loop exit
if (Dest != LoopExit) {
BasicBlock *BB = Latches[i];
- for (BasicBlock *Succ : successors(BB)) {
- if (Succ == Headers[i])
+ for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB);
+ SI != SE; ++SI) {
+ if (*SI == Headers[i])
continue;
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (BasicBlock::iterator BBI = (*SI)->begin();
PHINode *Phi = dyn_cast<PHINode>(BBI); ++BBI) {
Phi->removeIncomingValue(BB, false);
}
Modified: llvm/trunk/lib/Transforms/Utils/LoopUnrollRuntime.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LoopUnrollRuntime.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/LoopUnrollRuntime.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/LoopUnrollRuntime.cpp Mon Jul 21 12:06:51 2014
@@ -66,8 +66,9 @@ static void ConnectProlog(Loop *L, Value
// 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 (BasicBlock *Succ : successors(Latch)) {
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (succ_iterator SBI = succ_begin(Latch), SBE = succ_end(Latch);
+ SBI != SBE; ++SBI) {
+ for (BasicBlock::iterator BBI = (*SBI)->begin();
PHINode *PN = dyn_cast<PHINode>(BBI); ++BBI) {
// Add a new PHI node to the prolog end block and add the
Modified: llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp Mon Jul 21 12:06:51 2014
@@ -822,7 +822,9 @@ 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.
- for (BasicBlock *P : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *P = *PI;
+
// The value is not live into a predecessor if it defines the value.
if (DefBlocks.count(P))
continue;
@@ -883,8 +885,9 @@ void PromoteMem2Reg::DetermineInsertionP
DomTreeNode *Node = Worklist.pop_back_val();
BasicBlock *BB = Node->getBlock();
- for (BasicBlock *Succ : successors(BB)) {
- DomTreeNode *SuccNode = DT.getNode(Succ);
+ for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE;
+ ++SI) {
+ DomTreeNode *SuccNode = DT.getNode(*SI);
// Quickly skip all CFG edges that are also dominator tree edges instead
// of catching them below.
Modified: llvm/trunk/lib/Transforms/Utils/SSAUpdater.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SSAUpdater.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/SSAUpdater.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/SSAUpdater.cpp Mon Jul 21 12:06:51 2014
@@ -110,7 +110,8 @@ Value *SSAUpdater::GetValueInMiddleOfBlo
}
} else {
bool isFirstPred = true;
- for (BasicBlock *PredBB : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *PredBB = *PI;
Value *PredVal = GetValueAtEndOfBlock(PredBB);
PredValues.push_back(std::make_pair(PredBB, PredVal));
@@ -247,7 +248,8 @@ public:
for (unsigned PI = 0, E = SomePhi->getNumIncomingValues(); PI != E; ++PI)
Preds->push_back(SomePhi->getIncomingBlock(PI));
} else {
- Preds->insert(Preds->end(), pred_begin(BB), pred_end(BB));
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
+ Preds->push_back(*PI);
}
}
Modified: llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp Mon Jul 21 12:06:51 2014
@@ -130,9 +130,9 @@ static bool SafeToMergeTerminators(Termi
BasicBlock *SI2BB = SI2->getParent();
SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
- for (BasicBlock *Succ : successors(SI2BB))
- if (SI1Succs.count(Succ))
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I)
+ if (SI1Succs.count(*I))
+ for (BasicBlock::iterator BBI = (*I)->begin();
isa<PHINode>(BBI); ++BBI) {
PHINode *PN = cast<PHINode>(BBI);
if (PN->getIncomingValueForBlock(SI1BB) !=
@@ -171,9 +171,9 @@ static bool isProfitableToFoldUnconditio
BasicBlock *SI1BB = SI1->getParent();
BasicBlock *SI2BB = SI2->getParent();
SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
- for (BasicBlock *Succ : successors(SI2BB))
- if (SI1Succs.count(Succ))
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I)
+ if (SI1Succs.count(*I))
+ for (BasicBlock::iterator BBI = (*I)->begin();
isa<PHINode>(BBI); ++BBI) {
PHINode *PN = cast<PHINode>(BBI);
if (PN->getIncomingValueForBlock(SI1BB) != Cond ||
@@ -683,9 +683,9 @@ SimplifyEqualityComparisonWithOnlyPredec
// Remove PHI node entries for dead edges.
BasicBlock *CheckEdge = TheRealDest;
- for (BasicBlock *Succ : successors(TIBB))
- if (Succ != CheckEdge)
- Succ->removePredecessor(TIBB);
+ for (succ_iterator SI = succ_begin(TIBB), e = succ_end(TIBB); SI != e; ++SI)
+ if (*SI != CheckEdge)
+ (*SI)->removePredecessor(TIBB);
else
CheckEdge = nullptr;
@@ -981,9 +981,9 @@ bool SimplifyCFGOpt::FoldValueComparison
// to put the select in this case.
static bool isSafeToHoistInvoke(BasicBlock *BB1, BasicBlock *BB2,
Instruction *I1, Instruction *I2) {
- for (BasicBlock *Succ : successors(BB1)) {
+ for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) {
PHINode *PN;
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (BasicBlock::iterator BBI = SI->begin();
(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;
- for (BasicBlock *Succ : successors(BB1)) {
+ for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) {
PHINode *PN;
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (BasicBlock::iterator BBI = SI->begin();
(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;
- for (BasicBlock *Succ : successors(BB1)) {
+ for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) {
PHINode *PN;
- for (BasicBlock::iterator BBI = Succ->begin();
+ for (BasicBlock::iterator BBI = SI->begin();
(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.
- for (BasicBlock *Succ : successors(BB1))
- AddPredecessorToBlock(Succ, BIParent, BB1);
+ for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI)
+ AddPredecessorToBlock(*SI, BIParent, BB1);
EraseTerminatorInstAndDCECond(BI);
return true;
@@ -2051,7 +2051,8 @@ bool llvm::FoldBranchToCommonDest(Branch
if (TrueDest == BB || FalseDest == BB)
return false;
- for (BasicBlock *PredBlock : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *PredBlock = *PI;
BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator());
// Check that we have two conditional branches. If there is a PHI node in
@@ -2884,8 +2885,8 @@ bool SimplifyCFGOpt::SimplifyResume(Resu
// Turn all invokes that unwind here into calls and delete the basic block.
bool InvokeRequiresTableEntry = false;
bool Changed = false;
- for (BasicBlock *Pred : predecessors(BB)) {
- InvokeInst *II = cast<InvokeInst>(Pred->getTerminator());
+ for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE;) {
+ InvokeInst *II = cast<InvokeInst>((*PI++)->getTerminator());
if (II->hasFnAttr(Attribute::UWTable)) {
// Don't remove an `invoke' instruction if the ABI requires an entry into
@@ -2932,7 +2933,8 @@ bool SimplifyCFGOpt::SimplifyReturn(Retu
// Find predecessors that end with branches.
SmallVector<BasicBlock*, 8> UncondBranchPreds;
SmallVector<BranchInst*, 8> CondBranchPreds;
- for (BasicBlock *P : predecessors(BB)) {
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
+ BasicBlock *P = *PI;
TerminatorInst *PTI = P->getTerminator();
if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) {
if (BI->isUnconditional())
@@ -4098,8 +4100,8 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
return SimplifyCFG(BB, TTI, DL) | true;
// Scan predecessor blocks for conditional branches.
- for (BasicBlock *Pred : predecessors(BB))
- if (BranchInst *PBI = dyn_cast<BranchInst>(Pred->getTerminator()))
+ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
+ if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
if (PBI != BI && PBI->isConditional())
if (SimplifyCondBranchToCondBranch(PBI, BI))
return SimplifyCFG(BB, TTI, DL) | true;
Modified: llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp (original)
+++ llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp Mon Jul 21 12:06:51 2014
@@ -2950,8 +2950,9 @@ InnerLoopVectorizer::createBlockInMask(B
Value *Zero = ConstantInt::get(IntegerType::getInt1Ty(BB->getContext()), 0);
VectorParts BlockMask = getVectorValue(Zero);
- for (BasicBlock *Pred : predecessors(BB)) {
- VectorParts EM = createEdgeMask(Pred, BB);
+ // For each pred:
+ for (pred_iterator it = pred_begin(BB), e = pred_end(BB); it != e; ++it) {
+ VectorParts EM = createEdgeMask(*it, BB);
for (unsigned part = 0; part < UF; ++part)
BlockMask[part] = Builder.CreateOr(BlockMask[part], EM[part]);
}
Modified: llvm/trunk/tools/bugpoint/CrashDebugger.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/bugpoint/CrashDebugger.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/tools/bugpoint/CrashDebugger.cpp (original)
+++ llvm/trunk/tools/bugpoint/CrashDebugger.cpp Mon Jul 21 12:06:51 2014
@@ -292,8 +292,8 @@ bool ReduceCrashingBlocks::TestBlocks(st
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 (BasicBlock *Succ : successors(BB))
- Succ->removePredecessor(BB);
+ for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
+ (*SI)->removePredecessor(BB);
TerminatorInst *BBTerm = BB->getTerminator();
Modified: llvm/trunk/tools/llvm-diff/DifferenceEngine.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-diff/DifferenceEngine.cpp?rev=213562&r1=213561&r2=213562&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-diff/DifferenceEngine.cpp (original)
+++ llvm/trunk/tools/llvm-diff/DifferenceEngine.cpp Mon Jul 21 12:06:51 2014
@@ -125,8 +125,8 @@ class FunctionDifferenceEngine {
unsigned getUnprocPredCount(BasicBlock *Block) const {
unsigned Count = 0;
- for (BasicBlock *Pred : predecessors(Block))
- if (!Blocks.count(Pred)) Count++;
+ for (pred_iterator I = pred_begin(Block), E = pred_end(Block); I != E; ++I)
+ if (!Blocks.count(*I)) Count++;
return Count;
}
More information about the llvm-commits
mailing list