From 7e529e4b3cbce226f26f840e434332cf0d4e2c32 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 15 Nov 2004 05:45:33 +0000 Subject: Two minor improvements: 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 --- lib/Transforms/Scalar/SCCP.cpp | 50 +++++++++++++++++++++++++++++++----------- 1 file changed, 37 insertions(+), 13 deletions(-) (limited to 'lib') diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index d89c08d..f302552 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -185,12 +185,12 @@ private: hash_map::iterator I = ValueState.find(V); if (I != ValueState.end()) return I->second; // Common case, in the map - if (isa(V)) { - // Nothing to do, remain undefined. - } else if (Constant *CPV = dyn_cast(V)) { - ValueState[CPV].markConstant(CPV); // Constants are constant - } else if (isa(V)) { // Arguments are overdefined - ValueState[V].markOverdefined(); + if (Constant *CPV = dyn_cast(V)) { + if (isa(V)) { + // Nothing to do, remain undefined. + } else { + ValueState[CPV].markConstant(CPV); // Constants are constant + } } // All others are underdefined by default... return ValueState[V]; @@ -829,25 +829,49 @@ FunctionPass *llvm::createSCCPPass() { // and return true if the function was modified. // bool SCCP::runOnFunction(Function &F) { + DEBUG(std::cerr << "SCCP on function '" << F.getName() << "'\n"); SCCPSolver Solver; // Mark the first block of the function as being executable. Solver.MarkBlockExecutable(F.begin()); + // Mark all arguments to the function as being overdefined. + hash_map &Values = Solver.getValueMapping(); + for (Function::aiterator AI = F.abegin(), E = F.aend(); AI != E; ++AI) + Values[AI].markOverdefined(); + // Solve for constants. Solver.Solve(); - DEBUG(std::cerr << "SCCP on function '" << F.getName() << "'\n"); - DEBUG(std::set &ExecutableBBs = Solver.getExecutableBlocks(); - for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) - if (!ExecutableBBs.count(I)) - std::cerr << " BasicBlock Dead:" << *I); + bool MadeChanges = false; + + // If we decided that there are basic blocks that are dead in this function, + // delete their contents now. Note that we cannot actually delete the blocks, + // as we cannot modify the CFG of the function. + // + std::set &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 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 // constants if we have found them to be of constant values. // - bool MadeChanges = false; - hash_map &Values = Solver.getValueMapping(); for (Function::iterator BB = F.begin(), BBE = F.end(); BB != BBE; ++BB) for (BasicBlock::iterator BI = BB->begin(), E = BB->end(); BI != E; ) { Instruction *Inst = BI++; -- cgit v1.1