6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-14 11:32:34 +00:00
Code Issues Projects Releases Wiki Activity

Two minor improvements:

Browse Source 
1. Speedup getValueState by having it not consider Arguments.  It's better
    to just add them before we start SCCP'ing.
 2. SCCP can delete the contents of dead blocks.  No really, it's ok!  This
    reduces the size of the IR for subsequent passes, even though
    simplifycfg would do the same job.  In practice, simplifycfg does not
    run until much later than sccp in gccas


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@17820 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2004-11-15 05:45:33 +00:00
parent 14ab537b5a
commit 7e529e4b3c
1 changed files with 37 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
lib/Transforms/Scalar/SCCP.cpp
View File

@ -185,12 +185,12 @@ private:
hash_map<Value*, LatticeVal>::iterator I = ValueState.find(V); hash_map<Value*, LatticeVal>::iterator I = ValueState.find(V);
if (I != ValueState.end()) return I->second; // Common case, in the map if (I != ValueState.end()) return I->second; // Common case, in the map
if (isa<UndefValue>(V)) { if (Constant *CPV = dyn_cast<Constant>(V)) {
// Nothing to do, remain undefined. if (isa<UndefValue>(V)) {
} else if (Constant *CPV = dyn_cast<Constant>(V)) { // Nothing to do, remain undefined.
ValueState[CPV].markConstant(CPV); // Constants are constant } else {
} else if (isa<Argument>(V)) { // Arguments are overdefined ValueState[CPV].markConstant(CPV); // Constants are constant
ValueState[V].markOverdefined(); }
} }
// All others are underdefined by default... // All others are underdefined by default...
return ValueState[V]; return ValueState[V];
@ -829,25 +829,49 @@ FunctionPass *llvm::createSCCPPass() {
// and return true if the function was modified. // and return true if the function was modified.
// //
bool SCCP::runOnFunction(Function &F) { bool SCCP::runOnFunction(Function &F) {
DEBUG(std::cerr << "SCCP on function '" << F.getName() << "'\n");
SCCPSolver Solver; SCCPSolver Solver;
// Mark the first block of the function as being executable. // Mark the first block of the function as being executable.
Solver.MarkBlockExecutable(F.begin()); Solver.MarkBlockExecutable(F.begin());
// Mark all arguments to the function as being overdefined.
hash_map<Value*, LatticeVal> &Values = Solver.getValueMapping();
for (Function::aiterator AI = F.abegin(), E = F.aend(); AI != E; ++AI)
Values[AI].markOverdefined();
// Solve for constants. // Solve for constants.
Solver.Solve(); Solver.Solve();
DEBUG(std::cerr << "SCCP on function '" << F.getName() << "'\n"); bool MadeChanges = false;
DEBUG(std::set<BasicBlock*> &ExecutableBBs = Solver.getExecutableBlocks();
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) // If we decided that there are basic blocks that are dead in this function,
if (!ExecutableBBs.count(I)) // delete their contents now. Note that we cannot actually delete the blocks,
std::cerr << " BasicBlock Dead:" << *I); // as we cannot modify the CFG of the function.
//
std::set<BasicBlock*> &ExecutableBBs = Solver.getExecutableBlocks();
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
if (!ExecutableBBs.count(BB)) {
DEBUG(std::cerr << " BasicBlock Dead:" << *BB);
// Delete the instructions backwards, as it has a reduced likelihood of
// having to update as many def-use and use-def chains.
std::vector<Instruction*> Insts;
for (BasicBlock::iterator I = BB->begin(), E = BB->getTerminator();
I != E; ++I)
Insts.push_back(I);
while (!Insts.empty()) {
Instruction *I = Insts.back();
Insts.pop_back();
if (!I->use_empty())
I->replaceAllUsesWith(UndefValue::get(I->getType()));
BB->getInstList().erase(I);
MadeChanges = true;
}
}
// Iterate over all of the instructions in a function, replacing them with // Iterate over all of the instructions in a function, replacing them with
// constants if we have found them to be of constant values. // constants if we have found them to be of constant values.
// //
bool MadeChanges = false;
hash_map<Value*, LatticeVal> &Values = Solver.getValueMapping();
for (Function::iterator BB = F.begin(), BBE = F.end(); BB != BBE; ++BB) for (Function::iterator BB = F.begin(), BBE = F.end(); BB != BBE; ++BB)
for (BasicBlock::iterator BI = BB->begin(), E = BB->end(); BI != E; ) { for (BasicBlock::iterator BI = BB->begin(), E = BB->end(); BI != E; ) {
Instruction *Inst = BI++; Instruction *Inst = BI++;