6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-01 00:33:09 +00:00
Code Issues Projects Releases Wiki Activity

Undo previous check-in.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40698 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Devang Patel 2007-08-01 23:24:50 +00:00
parent caf778ab3b
commit 2f2e519083
2 changed files with 21 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
lib/Transforms/Scalar/LoopUnswitch.cpp
View File

@ -543,8 +543,17 @@ void LoopUnswitch::EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
std::swap(TrueDest, FalseDest);
// Insert the new branch.
new BranchInst(TrueDest, FalseDest, BranchVal, InsertPt);
BranchInst *BRI = new BranchInst(TrueDest, FalseDest, BranchVal, InsertPt);
// Update dominator info.
// BranchVal is a new preheader so it dominates true and false destination
// loop headers.
if (DominatorTree *DT = getAnalysisToUpdate<DominatorTree>()) {
DT->changeImmediateDominator(TrueDest, BRI->getParent());
DT->changeImmediateDominator(FalseDest, BRI->getParent());
}
// No need to update DominanceFrontier. BRI->getParent() dominated TrueDest
// and FalseDest anyway. Now it immediately dominates them.
}
@ -626,14 +635,12 @@ void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
// Split all of the edges from inside the loop to their exit blocks. Update
// the appropriate Phi nodes as we do so.
SmallVector<BasicBlock *,8> MiddleBlocks;
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
BasicBlock *ExitBlock = ExitBlocks[i];
std::vector<BasicBlock*> Preds(pred_begin(ExitBlock), pred_end(ExitBlock));
for (unsigned j = 0, e = Preds.size(); j != e; ++j) {
BasicBlock* MiddleBlock = SplitEdge(Preds[j], ExitBlock, this);
MiddleBlocks.push_back(MiddleBlock);
BasicBlock* StartBlock = Preds[j];
BasicBlock* EndBlock;
if (MiddleBlock->getSinglePredecessor() == ExitBlock) {
@ -678,9 +685,6 @@ void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
// Add exit blocks to the loop blocks.
LoopBlocks.insert(LoopBlocks.end(), ExitBlocks.begin(), ExitBlocks.end());
DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>();
DominatorTree *DT = getAnalysisToUpdate<DominatorTree>();
// Next step, clone all of the basic blocks that make up the loop (including
// the loop preheader and exit blocks), keeping track of the mapping between
// the instructions and blocks.
@ -694,21 +698,16 @@ void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
LPM->cloneBasicBlockSimpleAnalysis(LoopBlocks[i], New, L);
}
// OutSiders are basic block that are dominated by original header and
// at the same time they are not part of loop.
SmallPtrSet<BasicBlock *, 8> OutSiders;
if (DT) {
DomTreeNode *OrigHeaderNode = DT->getNode(OrigHeader);
for(std::vector<DomTreeNode*>::iterator DI = OrigHeaderNode->begin(),
DE = OrigHeaderNode->end(); DI != DE; ++DI) {
BasicBlock *B = (*DI)->getBlock();
DenseMap<const Value*, Value*>::iterator VI = ValueMap.find(B);
if (VI == ValueMap.end())
OutSiders.insert(B);
// Update dominator info
DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>();
if (DominatorTree *DT = getAnalysisToUpdate<DominatorTree>())
for (unsigned i = 0, e = LoopBlocks.size(); i != e; ++i) {
BasicBlock *LBB = LoopBlocks[i];
BasicBlock *NBB = NewBlocks[i];
CloneDomInfo(NBB, LBB, NewPreheader, OrigPreheader,
OrigHeader, DT, DF, ValueMap);
}
}
// Splice the newly inserted blocks into the function right before the
// original preheader.
F->getBasicBlockList().splice(LoopBlocks[0], F->getBasicBlockList(),
@ -760,61 +759,7 @@ void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
EmitPreheaderBranchOnCondition(LIC, Val, NewBlocks[0], LoopBlocks[0], OldBR);
OldBR->eraseFromParent();
LPM->deleteSimpleAnalysisValue(OldBR, L);
// Update dominator info
if (DF && DT) {
// Clone dominator info for all cloned basic block.
for (unsigned i = 0, e = LoopBlocks.size(); i != e; ++i) {
BasicBlock *LBB = LoopBlocks[i];
BasicBlock *NBB = NewBlocks[i];
CloneDomInfo(NBB, LBB, NewPreheader, OrigPreheader,
OrigHeader, DT, DF, ValueMap);
// Remove any OutSiders from LBB and NBB's dominance frontier.
DominanceFrontier::iterator LBBI = DF->find(LBB);
if (LBBI != DF->end()) {
DominanceFrontier::DomSetType &LBSet = LBBI->second;
for (DominanceFrontier::DomSetType::iterator LI = LBSet.begin(),
LE = LBSet.end(); LI != LE; ++LI) {
BasicBlock *B = *LI;
if (OutSiders.count(B))
DF->removeFromFrontier(LBBI, B);
}
}
// Remove any OutSiders from LBB and NBB's dominance frontier.
DominanceFrontier::iterator NBBI = DF->find(NBB);
if (NBBI != DF->end()) {
DominanceFrontier::DomSetType NBSet = NBBI->second;
for (DominanceFrontier::DomSetType::iterator NI = NBSet.begin(),
NE = NBSet.end(); NI != NE; ++NI) {
BasicBlock *B = *NI;
if (OutSiders.count(B))
DF->removeFromFrontier(NBBI, B);
}
}
}
// MiddleBlocks are dominated by original pre header. SplitEdge updated
// MiddleBlocks' dominance frontier appropriately.
for (unsigned i = 0, e = MiddleBlocks.size(); i != e; ++i) {
BasicBlock *MBB = MiddleBlocks[i];
DT->changeImmediateDominator(MBB, OrigPreheader);
}
// All Outsiders are now dominated by original pre header.
for (SmallPtrSet<BasicBlock *, 8>::iterator OI = OutSiders.begin(),
OE = OutSiders.end(); OI != OE; ++OI) {
BasicBlock *OB = *OI;
DT->changeImmediateDominator(OB, OrigPreheader);
}
// New loop headers are dominated by original preheader
DT->changeImmediateDominator(NewBlocks[0], OrigPreheader);
DT->changeImmediateDominator(LoopBlocks[0], OrigPreheader);
}
LoopProcessWorklist.push_back(NewLoop);
redoLoop = true;

10
lib/VMCore/Dominators.cpp
View File

@ -627,15 +627,6 @@ void DominanceFrontier::splitBlock(BasicBlock *NewBB) {
if (!DT.dominates(NewBB, NewBBSucc))
NewBBDominatesNewBBSucc = false;
// NewBBSucc inherites original NewBB frontier.
DominanceFrontier::iterator NewBBI = find(NewBB);
if (NewBBI != end()) {
DominanceFrontier::DomSetType NewBBSet = NewBBI->second;
DominanceFrontier::DomSetType NewBBSuccSet;
NewBBSuccSet.insert(NewBBSet.begin(), NewBBSet.end());
addBasicBlock(NewBBSucc, NewBBSuccSet);
}
// If NewBB dominates NewBBSucc, then DF(NewBB) is now going to be the
// DF(PredBlocks[0]) without the stuff that the new block does not dominate
// a predecessor of.
@ -657,6 +648,7 @@ void DominanceFrontier::splitBlock(BasicBlock *NewBB) {
++SetI;
}
DominanceFrontier::iterator NewBBI = find(NewBB);
if (NewBBI != end()) {
DominanceFrontier::DomSetType NewBBSet = NewBBI->second;
NewBBSet.insert(Set.begin(), Set.end());