[llvm-commits] CVS: llvm/lib/Transforms/Scalar/LICM.cpp
Owen Anderson
resistor at mac.com
Mon Apr 23 23:40:56 PDT 2007
Changes in directory llvm/lib/Transforms/Scalar:
LICM.cpp updated: 1.94 -> 1.95
---
Log message:
Rollback some changes that adversely affected performance. I'm currently rethinking
my approach to this, so hopefully I'll find a way to do this without making this slower.
---
Diffs of the changes: (+26 -22)
LICM.cpp | 48 ++++++++++++++++++++++++++----------------------
1 files changed, 26 insertions(+), 22 deletions(-)
Index: llvm/lib/Transforms/Scalar/LICM.cpp
diff -u llvm/lib/Transforms/Scalar/LICM.cpp:1.94 llvm/lib/Transforms/Scalar/LICM.cpp:1.95
--- llvm/lib/Transforms/Scalar/LICM.cpp:1.94 Sat Apr 21 02:11:47 2007
+++ llvm/lib/Transforms/Scalar/LICM.cpp Tue Apr 24 01:40:39 2007
@@ -72,6 +72,7 @@
AU.setPreservesCFG();
AU.addRequiredID(LoopSimplifyID);
AU.addRequired<LoopInfo>();
+ AU.addRequired<DominatorTree>();
AU.addRequired<ETForest>();
AU.addRequired<DominanceFrontier>(); // For scalar promotion (mem2reg)
AU.addRequired<AliasAnalysis>();
@@ -86,7 +87,8 @@
// Various analyses that we use...
AliasAnalysis *AA; // Current AliasAnalysis information
LoopInfo *LI; // Current LoopInfo
- ETForest *ET; // ETForest for the current Loop...
+ ETForest *ET; // ETForest for the current loop..
+ DominatorTree *DT; // Dominator Tree for the current Loop...
DominanceFrontier *DF; // Current Dominance Frontier
// State that is updated as we process loops
@@ -98,19 +100,19 @@
/// SinkRegion - Walk the specified region of the CFG (defined by all blocks
/// dominated by the specified block, and that are in the current loop) in
- /// reverse depth first order w.r.t the ETForest. This allows us to
+ /// reverse depth first order w.r.t the DominatorTree. This allows us to
/// visit uses before definitions, allowing us to sink a loop body in one
/// pass without iteration.
///
- void SinkRegion(BasicBlock *BB);
+ void SinkRegion(DominatorTree::Node *N);
/// HoistRegion - Walk the specified region of the CFG (defined by all
/// blocks dominated by the specified block, and that are in the current
- /// loop) in depth first order w.r.t the ETForest. This allows us to
+ /// loop) in depth first order w.r.t the DominatorTree. This allows us to
/// visit definitions before uses, allowing us to hoist a loop body in one
/// pass without iteration.
///
- void HoistRegion(BasicBlock *BB);
+ void HoistRegion(DominatorTree::Node *N);
/// inSubLoop - Little predicate that returns true if the specified basic
/// block is in a subloop of the current one, not the current one itself.
@@ -135,20 +137,21 @@
if (BlockInLoop == LoopHeader)
return true;
- BasicBlock *IDom = ExitBlock;
+ DominatorTree::Node *BlockInLoopNode = DT->getNode(BlockInLoop);
+ DominatorTree::Node *IDom = DT->getNode(ExitBlock);
// Because the exit block is not in the loop, we know we have to get _at
// least_ its immediate dominator.
do {
// Get next Immediate Dominator.
- IDom = ET->getIDom(IDom);
+ IDom = IDom->getIDom();
// If we have got to the header of the loop, then the instructions block
// did not dominate the exit node, so we can't hoist it.
- if (IDom == LoopHeader)
+ if (IDom->getBlock() == LoopHeader)
return false;
- } while (IDom != BlockInLoop);
+ } while (IDom != BlockInLoopNode);
return true;
}
@@ -212,6 +215,7 @@
LI = &getAnalysis<LoopInfo>();
AA = &getAnalysis<AliasAnalysis>();
DF = &getAnalysis<DominanceFrontier>();
+ DT = &getAnalysis<DominatorTree>();
ET = &getAnalysis<ETForest>();
CurAST = new AliasSetTracker(*AA);
@@ -251,8 +255,8 @@
// us to sink instructions in one pass, without iteration. AFter sinking
// instructions, we perform another pass to hoist them out of the loop.
//
- SinkRegion(L->getHeader());
- HoistRegion(L->getHeader());
+ SinkRegion(DT->getNode(L->getHeader()));
+ HoistRegion(DT->getNode(L->getHeader()));
// Now that all loop invariants have been removed from the loop, promote any
// memory references to scalars that we can...
@@ -269,19 +273,19 @@
/// SinkRegion - Walk the specified region of the CFG (defined by all blocks
/// dominated by the specified block, and that are in the current loop) in
-/// reverse depth first order w.r.t the ETForest. This allows us to visit
+/// reverse depth first order w.r.t the DominatorTree. This allows us to visit
/// uses before definitions, allowing us to sink a loop body in one pass without
/// iteration.
///
-void LICM::SinkRegion(BasicBlock *BB) {
- assert(BB != 0 && "Null sink block?");
+void LICM::SinkRegion(DominatorTree::Node *N) {
+ assert(N != 0 && "Null dominator tree node?");
+ BasicBlock *BB = N->getBlock();
// If this subregion is not in the top level loop at all, exit.
if (!CurLoop->contains(BB)) return;
// We are processing blocks in reverse dfo, so process children first...
- std::vector<BasicBlock*> Children;
- ET->getChildren(BB, Children);
+ const std::vector<DominatorTree::Node*> &Children = N->getChildren();
for (unsigned i = 0, e = Children.size(); i != e; ++i)
SinkRegion(Children[i]);
@@ -307,11 +311,12 @@
/// HoistRegion - Walk the specified region of the CFG (defined by all blocks
/// dominated by the specified block, and that are in the current loop) in depth
-/// first order w.r.t the ETForest. This allows us to visit definitions
+/// first order w.r.t the DominatorTree. This allows us to visit definitions
/// before uses, allowing us to hoist a loop body in one pass without iteration.
///
-void LICM::HoistRegion(BasicBlock *BB) {
- assert(BB != 0 && "Null hoist block?");
+void LICM::HoistRegion(DominatorTree::Node *N) {
+ assert(N != 0 && "Null dominator tree node?");
+ BasicBlock *BB = N->getBlock();
// If this subregion is not in the top level loop at all, exit.
if (!CurLoop->contains(BB)) return;
@@ -331,8 +336,7 @@
hoist(I);
}
- std::vector<BasicBlock*> Children;
- ET->getChildren(BB, Children);
+ const std::vector<DominatorTree::Node*> &Children = N->getChildren();
for (unsigned i = 0, e = Children.size(); i != e; ++i)
HoistRegion(Children[i]);
}
@@ -603,7 +607,7 @@
std::vector<BasicBlock*> ExitBlocks;
CurLoop->getExitBlocks(ExitBlocks);
- // For each exit block, walk up the ET until the
+ // For each exit block, get the DT node and walk up the DT until the
// instruction's basic block is found or we exit the loop.
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
if (!isExitBlockDominatedByBlockInLoop(ExitBlocks[i], Inst.getParent()))
More information about the llvm-commits
mailing list