Changes in directory llvm/lib/Transforms/Scalar:
CorrelatedExprs.cpp updated: 1.63 -> 1.64 --- Log message: Use DominatorTree instead of ETForest. --- Diffs of the changes: (+25 -23) CorrelatedExprs.cpp | 48 +++++++++++++++++++++++++----------------------- 1 files changed, 25 insertions(+), 23 deletions(-) Index: llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp diff -u llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp:1.63 llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp:1.64 --- llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp:1.63 Mon Jun 4 18:45:02 2007 +++ llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp Thu Jun 7 16:35:27 2007 @@ -223,7 +223,7 @@ class VISIBILITY_HIDDEN CEE : public FunctionPass { std::map<Value*, unsigned> RankMap; std::map<BasicBlock*, RegionInfo> RegionInfoMap; - ETForest *EF; + DominatorTree *DT; public: static char ID; // Pass identification, replacement for typeid CEE() : FunctionPass((intptr_t)&ID) {} @@ -232,7 +232,7 @@ // We don't modify the program, so we preserve all analyses virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired<ETForest>(); + AU.addRequired<DominatorTree>(); AU.addRequiredID(BreakCriticalEdgesID); }; @@ -304,7 +304,7 @@ // Traverse the dominator tree, computing information for each node in the // tree. Note that our traversal will not even touch unreachable basic // blocks. - EF = &getAnalysis<ETForest>(); + DT = &getAnalysis<DominatorTree>(); std::set<BasicBlock*> VisitedBlocks; bool Changed = TransformRegion(&F.getEntryBlock(), VisitedBlocks); @@ -351,14 +351,14 @@ // blocks that are dominated by this one, we can safely propagate the // information down now. // - std::vector<BasicBlock*> children; - EF->getETNodeChildren(BB, children); + DomTreeNode *BBDom = DT->getNode(BB); if (!RI.empty()) { // Time opt: only propagate if we can change something - for (std::vector<BasicBlock*>::iterator CI = children.begin(), - E = children.end(); CI != E; ++CI) { - assert(RegionInfoMap.find(*CI) == RegionInfoMap.end() && + for (std::vector<DomTreeNode*>::iterator DI = BBDom->begin(), + E = BBDom->end(); DI != E; ++DI) { + BasicBlock *ChildBB = (*DI)->getBlock(); + assert(RegionInfoMap.find(ChildBB) == RegionInfoMap.end() && "RegionInfo should be calculated in dominanace order!"); - getRegionInfo(*CI) = RI; + getRegionInfo(ChildBB) = RI; } } @@ -383,9 +383,11 @@ } // Now that all of our successors have information, recursively process them. - for (std::vector<BasicBlock*>::iterator CI = children.begin(), - E = children.end(); CI != E; ++CI) - Changed |= TransformRegion(*CI, VisitedBlocks); + for (std::vector<DomTreeNode*>::iterator DI = BBDom->begin(), + E = BBDom->end(); DI != E; ++DI) { + BasicBlock *ChildBB = (*DI)->getBlock(); + Changed |= TransformRegion(ChildBB, VisitedBlocks); + } return Changed; } @@ -552,7 +554,7 @@ // insert dead phi nodes, but it is more trouble to see if they are used than // to just blindly insert them. // - if (EF->dominates(OldSucc, Dest)) { + if (DT->dominates(OldSucc, Dest)) { // RegionExitBlocks - Find all of the blocks that are not dominated by Dest, // but have predecessors that are. Additionally, prune down the set to only // include blocks that are dominated by OldSucc as well. @@ -652,7 +654,7 @@ for (Value::use_iterator I = Orig->use_begin(), E = Orig->use_end(); I != E; ++I) if (Instruction *User = dyn_cast<Instruction>(*I)) - if (EF->dominates(RegionDominator, User->getParent())) + if (DT->dominates(RegionDominator, User->getParent())) InstsToChange.push_back(User); else if (PHINode *PN = dyn_cast<PHINode>(User)) { PHIsToChange.push_back(PN); @@ -665,7 +667,7 @@ PHINode *PN = PHIsToChange[i]; for (unsigned j = 0, e = PN->getNumIncomingValues(); j != e; ++j) if (PN->getIncomingValue(j) == Orig && - EF->dominates(RegionDominator, PN->getIncomingBlock(j))) + DT->dominates(RegionDominator, PN->getIncomingBlock(j))) PN->setIncomingValue(j, New); } @@ -679,7 +681,7 @@ // values that correspond to basic blocks in the region. for (unsigned j = 0, e = PN->getNumIncomingValues(); j != e; ++j) if (PN->getIncomingValue(j) == Orig && - EF->dominates(RegionDominator, PN->getIncomingBlock(j))) + DT->dominates(RegionDominator, PN->getIncomingBlock(j))) PN->setIncomingValue(j, New); } else { @@ -689,14 +691,14 @@ static void CalcRegionExitBlocks(BasicBlock *Header, BasicBlock *BB, std::set<BasicBlock*> &Visited, - ETForest &EF, + DominatorTree &DT, std::vector<BasicBlock*> &RegionExitBlocks) { if (Visited.count(BB)) return; Visited.insert(BB); - if (EF.dominates(Header, BB)) { // Block in the region, recursively traverse + if (DT.dominates(Header, BB)) { // Block in the region, recursively traverse for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) - CalcRegionExitBlocks(Header, *I, Visited, EF, RegionExitBlocks); + CalcRegionExitBlocks(Header, *I, Visited, DT, RegionExitBlocks); } else { // Header does not dominate this block, but we have a predecessor that does // dominate us. Add ourself to the list. @@ -713,11 +715,11 @@ std::set<BasicBlock*> Visited; // Don't infinite loop // Recursively calculate blocks we are interested in... - CalcRegionExitBlocks(BB, BB, Visited, *EF, RegionExitBlocks); + CalcRegionExitBlocks(BB, BB, Visited, *DT, RegionExitBlocks); // Filter out blocks that are not dominated by OldSucc... for (unsigned i = 0; i != RegionExitBlocks.size(); ) { - if (EF->dominates(OldSucc, RegionExitBlocks[i])) + if (DT->dominates(OldSucc, RegionExitBlocks[i])) ++i; // Block is ok, keep it. else { // Move to end of list... @@ -746,7 +748,7 @@ PI != PE; ++PI) { // If the incoming edge is from the region dominated by BB, use BBVal, // otherwise use OldVal. - NewPN->addIncoming(EF->dominates(BB, *PI) ? BBVal : OldVal, *PI); + NewPN->addIncoming(DT->dominates(BB, *PI) ? BBVal : OldVal, *PI); } // Now make everyone dominated by this block use this new value! @@ -989,7 +991,7 @@ // here. This check is also effectively checking to make sure that Inst // is in the same function as our region (in case V is a global f.e.). // - if (EF->properlyDominates(Inst->getParent(), RI.getEntryBlock())) + if (DT->properlyDominates(Inst->getParent(), RI.getEntryBlock())) IncorporateInstruction(Inst, RI); } } _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits