RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 11:42:57 +01:00
Code Issues Projects Releases Wiki Activity

remove dead code

Browse Source 
llvm-svn: 83742
This commit is contained in:
Chris Lattner 2009-10-10 23:04:12 +00:00
parent db4d523cca
commit 31d3137c01
1 changed files with 0 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
lib/Transforms/Scalar/GVN.cpp
View File

@ -735,7 +735,6 @@ namespace {
Value *CollapsePhi(PHINode* p);
bool performPRE(Function& F);
Value *lookupNumber(BasicBlock *BB, uint32_t num);
Value *AttemptRedundancyElimination(Instruction *orig, unsigned valno);
void cleanupGlobalSets();
void verifyRemoved(const Instruction *I) const;
};
@ -1729,59 +1728,6 @@ Value *GVN::lookupNumber(BasicBlock *BB, uint32_t num) {
return 0;
}
/// AttemptRedundancyElimination - If the "fast path" of redundancy elimination
/// by inheritance from the dominator fails, see if we can perform phi
/// construction to eliminate the redundancy.
Value *GVN::AttemptRedundancyElimination(Instruction *orig, unsigned valno) {
BasicBlock *BaseBlock = orig->getParent();
SmallPtrSet<BasicBlock*, 4> Visited;
SmallVector<BasicBlock*, 8> Stack;
Stack.push_back(BaseBlock);
DenseMap<BasicBlock*, Value*> Results;
// Walk backwards through our predecessors, looking for instances of the
// value number we're looking for. Instances are recorded in the Results
// map, which is then used to perform phi construction.
while (!Stack.empty()) {
BasicBlock *Current = Stack.back();
Stack.pop_back();
// If we've walked all the way to a proper dominator, then give up. Cases
// where the instance is in the dominator will have been caught by the fast
// path, and any cases that require phi construction further than this are
// probably not worth it anyways. Note that this is a SIGNIFICANT compile
// time improvement.
if (DT->properlyDominates(Current, orig->getParent())) return 0;
DenseMap<BasicBlock*, ValueNumberScope*>::iterator LA =
localAvail.find(Current);
if (LA == localAvail.end()) return 0;
DenseMap<uint32_t, Value*>::iterator V = LA->second->table.find(valno);
if (V != LA->second->table.end()) {
// Found an instance, record it.
Results.insert(std::make_pair(Current, V->second));
continue;
}
// If we reach the beginning of the function, then give up.
if (pred_begin(Current) == pred_end(Current))
return 0;
for (pred_iterator PI = pred_begin(Current), PE = pred_end(Current);
PI != PE; ++PI)
if (Visited.insert(*PI))
Stack.push_back(*PI);
}
// If we didn't find instances, give up. Otherwise, perform phi construction.
if (Results.size() == 0)
return 0;
return GetValueForBlock(BaseBlock, orig, Results, true);
}
/// processInstruction - When calculating availability, handle an instruction
/// by inserting it into the appropriate sets
@ -1865,17 +1811,6 @@ bool GVN::processInstruction(Instruction *I,
toErase.push_back(I);
return true;
#if 0
// Perform slow-pathvalue-number based elimination with phi construction.
} else if (Value *repl = AttemptRedundancyElimination(I, Num)) {
// Remove it!
VN.erase(I);
I->replaceAllUsesWith(repl);
if (isa<PointerType>(repl->getType()))
MD->invalidateCachedPointerInfo(repl);
toErase.push_back(I);
return true;
#endif
} else {
localAvail[I->getParent()]->table.insert(std::make_pair(Num, I));
}