6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-07-22 23:24:59 +00:00
Code Issues Projects Releases Wiki Activity

Fix and implement ADCE to finally work!

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2720 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2002-05-22 21:32:16 +00:00
parent ff8207fc6c
commit d9036a1aad
1 changed files with 162 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

301
lib/Transforms/Scalar/ADCE.cpp
View File

@@ -13,6 +13,7 @@
#include "llvm/Analysis/Writer.h" #include "llvm/Analysis/Writer.h"
#include "llvm/iTerminators.h" #include "llvm/iTerminators.h"
#include "llvm/iPHINode.h" #include "llvm/iPHINode.h"
#include "llvm/Constant.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "Support/STLExtras.h" #include "Support/STLExtras.h"
#include "Support/DepthFirstIterator.h" #include "Support/DepthFirstIterator.h"
@@ -21,6 +22,9 @@
#include <iostream> #include <iostream>
using std::cerr; using std::cerr;
static Statistic<> NumBlockRemoved("adce\t\t- Number of basic blocks removed");
static Statistic<> NumInstRemoved ("adce\t\t- Number of instructions removed");
namespace { namespace {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@@ -33,7 +37,6 @@ class ADCE : public FunctionPass {
Function *Func; // The function that we are working on Function *Func; // The function that we are working on
std::vector<Instruction*> WorkList; // Instructions that just became live std::vector<Instruction*> WorkList; // Instructions that just became live
std::set<Instruction*> LiveSet; // The set of live instructions std::set<Instruction*> LiveSet; // The set of live instructions
bool MadeChanges;
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// The public interface for this class // The public interface for this class
@@ -41,18 +44,19 @@ class ADCE : public FunctionPass {
public: public:
const char *getPassName() const { return "Aggressive Dead Code Elimination"; } const char *getPassName() const { return "Aggressive Dead Code Elimination"; }
// doADCE - Execute the Aggressive Dead Code Elimination Algorithm // Execute the Aggressive Dead Code Elimination Algorithm
// //
virtual bool runOnFunction(Function *F) { virtual bool runOnFunction(Function *F) {
Func = F; MadeChanges = false; Func = F;
doADCE(getAnalysis<DominanceFrontier>(DominanceFrontier::PostDomID)); bool Changed = doADCE();
assert(WorkList.empty()); assert(WorkList.empty());
LiveSet.clear(); LiveSet.clear();
return MadeChanges; return Changed;
} }
// getAnalysisUsage - We require post dominance frontiers (aka Control // getAnalysisUsage - We require post dominance frontiers (aka Control
// Dependence Graph) // Dependence Graph)
virtual void getAnalysisUsage(AnalysisUsage &AU) const { virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired(DominatorTree::PostDomID);
AU.addRequired(DominanceFrontier::PostDomID); AU.addRequired(DominanceFrontier::PostDomID);
} }
@@ -64,7 +68,9 @@ private:
// doADCE() - Run the Aggressive Dead Code Elimination algorithm, returning // doADCE() - Run the Aggressive Dead Code Elimination algorithm, returning
// true if the function was modified. // true if the function was modified.
// //
void doADCE(DominanceFrontier &CDG); bool doADCE();
void markBlockAlive(BasicBlock *BB);
inline void markInstructionLive(Instruction *I) { inline void markInstructionLive(Instruction *I) {
if (LiveSet.count(I)) return; if (LiveSet.count(I)) return;
@@ -77,26 +83,38 @@ private:
DEBUG(cerr << "Terminat Live: " << BB->getTerminator()); DEBUG(cerr << "Terminat Live: " << BB->getTerminator());
markInstructionLive((Instruction*)BB->getTerminator()); markInstructionLive((Instruction*)BB->getTerminator());
} }
// fixupCFG - Walk the CFG in depth first order, eliminating references to
// dead blocks.
//
BasicBlock *fixupCFG(BasicBlock *Head, std::set<BasicBlock*> &VisitedBlocks,
const std::set<BasicBlock*> &AliveBlocks);
}; };
} // End of anonymous namespace } // End of anonymous namespace
Pass *createAggressiveDCEPass() { Pass *createAggressiveDCEPass() { return new ADCE(); }
return new ADCE();
void ADCE::markBlockAlive(BasicBlock *BB) {
// Mark the basic block as being newly ALIVE... and mark all branches that
// this block is control dependant on as being alive also...
//
DominanceFrontier &CDG =
getAnalysis<DominanceFrontier>(DominanceFrontier::PostDomID);
DominanceFrontier::const_iterator It = CDG.find(BB);
if (It != CDG.end()) {
// Get the blocks that this node is control dependant on...
const DominanceFrontier::DomSetType &CDB = It->second;
for_each(CDB.begin(), CDB.end(), // Mark all their terminators as live
bind_obj(this, &ADCE::markTerminatorLive));
}
// If this basic block is live, then the terminator must be as well!
markTerminatorLive(BB);
} }
// doADCE() - Run the Aggressive Dead Code Elimination algorithm, returning // doADCE() - Run the Aggressive Dead Code Elimination algorithm, returning
// true if the function was modified. // true if the function was modified.
// //
void ADCE::doADCE(DominanceFrontier &CDG) { bool ADCE::doADCE() {
DEBUG(cerr << "Function: " << Func); bool MadeChanges = false;
// Iterate over all of the instructions in the function, eliminating trivially // Iterate over all of the instructions in the function, eliminating trivially
// dead instructions, and marking instructions live that are known to be // dead instructions, and marking instructions live that are known to be
@@ -116,6 +134,7 @@ void ADCE::doADCE(DominanceFrontier &CDG) {
} else if (isInstructionTriviallyDead(I)) { } else if (isInstructionTriviallyDead(I)) {
// Remove the instruction from it's basic block... // Remove the instruction from it's basic block...
delete BB->getInstList().remove(II); delete BB->getInstList().remove(II);
++NumInstRemoved;
MadeChanges = true; MadeChanges = true;
} else { } else {
++II; // Increment the inst iterator if the inst wasn't deleted ++II; // Increment the inst iterator if the inst wasn't deleted
@@ -139,23 +158,22 @@ void ADCE::doADCE(DominanceFrontier &CDG) {
WorkList.pop_back(); WorkList.pop_back();
BasicBlock *BB = I->getParent(); BasicBlock *BB = I->getParent();
if (AliveBlocks.count(BB) == 0) { // Basic block not alive yet... if (!AliveBlocks.count(BB)) { // Basic block not alive yet...
// Mark the basic block as being newly ALIVE... and mark all branches that AliveBlocks.insert(BB); // Block is now ALIVE!
// this block is control dependant on as being alive also... markBlockAlive(BB); // Make it so now!
//
AliveBlocks.insert(BB); // Block is now ALIVE!
DominanceFrontier::const_iterator It = CDG.find(BB);
if (It != CDG.end()) {
// Get the blocks that this node is control dependant on...
const DominanceFrontier::DomSetType &CDB = It->second;
for_each(CDB.begin(), CDB.end(), // Mark all their terminators as live
bind_obj(this, &ADCE::markTerminatorLive));
}
// If this basic block is live, then the terminator must be as well!
markTerminatorLive(BB);
} }
// PHI nodes are a special case, because the incoming values are actually
// defined in the predecessor nodes of this block, meaning that the PHI
// makes the predecessors alive.
//
if (PHINode *PN = dyn_cast<PHINode>(I))
for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI)
if (!AliveBlocks.count(*PI)) {
AliveBlocks.insert(BB); // Block is now ALIVE!
markBlockAlive(*PI);
}
// Loop over all of the operands of the live instruction, making sure that // Loop over all of the operands of the live instruction, making sure that
// they are known to be alive as well... // they are known to be alive as well...
// //
@@ -174,124 +192,129 @@ void ADCE::doADCE(DominanceFrontier &CDG) {
} }
} }
// After the worklist is processed, recursively walk the CFG in depth first // Find the first postdominator of the entry node that is alive. Make it the
// order, patching up references to dead blocks... // new entry node...
// //
std::set<BasicBlock*> VisitedBlocks; DominatorTree &DT = getAnalysis<DominatorTree>(DominatorTree::PostDomID);
BasicBlock *EntryBlock = fixupCFG(Func->front(), VisitedBlocks, AliveBlocks);
// Now go through and tell dead blocks to drop all of their references so they // If there are some blocks dead...
// can be safely deleted. Also, as we are doing so, if the block has if (AliveBlocks.size() != Func->size()) {
// successors that are still live (and that have PHI nodes in them), remove // Insert a new entry node to eliminate the entry node as a special case.
// the entry for this block from the phi nodes. BasicBlock *NewEntry = new BasicBlock();
// NewEntry->getInstList().push_back(new BranchInst(Func->front()));
for (Function::iterator BI = Func->begin(), BE = Func->end(); BI != BE; ++BI){ Func->getBasicBlocks().push_front(NewEntry);
BasicBlock *BB = *BI; AliveBlocks.insert(NewEntry); // This block is always alive!
if (!AliveBlocks.count(BB)) {
// Remove entries from successors PHI nodes if they are still alive... // Loop over all of the alive blocks in the function. If any successor
for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI) // blocks are not alive, we adjust the outgoing branches to branch to the
if (AliveBlocks.count(*SI)) { // Only if the successor is alive... // first live postdominator of the live block, adjusting any PHI nodes in
BasicBlock *Succ = *SI; // the block to reflect this.
for (BasicBlock::iterator I = Succ->begin();// Loop over all PHI nodes //
PHINode *PN = dyn_cast<PHINode>(*I); ++I) for (Function::iterator I = Func->begin(), E = Func->end(); I != E; ++I)
PN->removeIncomingValue(BB); // Remove value for this block if (AliveBlocks.count(*I)) {
} BasicBlock *BB = *I;
TerminatorInst *TI = BB->getTerminator();
// Loop over all of the successors, looking for ones that are not alive
for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
if (!AliveBlocks.count(TI->getSuccessor(i))) {
// Scan up the postdominator tree, looking for the first
// postdominator that is alive, and the last postdominator that is
// dead...
//
DominatorTree::Node *LastNode = DT[TI->getSuccessor(i)];
DominatorTree::Node *NextNode = LastNode->getIDom();
while (!AliveBlocks.count(NextNode->getNode())) {
LastNode = NextNode;
NextNode = NextNode->getIDom();
}
// Get the basic blocks that we need...
BasicBlock *LastDead = LastNode->getNode();
BasicBlock *NextAlive = NextNode->getNode();
// Make the conditional branch now go to the next alive block...
TI->getSuccessor(i)->removePredecessor(BB);
TI->setSuccessor(i, NextAlive);
// If there are PHI nodes in NextAlive, we need to add entries to
// the PHI nodes for the new incoming edge. The incoming values
// should be identical to the incoming values for LastDead.
//
for (BasicBlock::iterator II = NextAlive->begin();
PHINode *PN = dyn_cast<PHINode>(*II); ++II) {
// Get the incoming value for LastDead...
int OldIdx = PN->getBasicBlockIndex(LastDead);
assert(OldIdx != -1 && "LastDead is not a pred of NextAlive!");
Value *InVal = PN->getIncomingValue(OldIdx);
// Add an incoming value for BB now...
PN->addIncoming(InVal, BB);
}
}
BB->dropAllReferences(); // Now loop over all of the instructions in the basic block, telling
} // dead instructions to drop their references. This is so that the next
// sweep over the program can safely delete dead instructions without
// other dead instructions still refering to them.
//
for (BasicBlock::iterator I = BB->begin(), E = BB->end()-1; I != E; ++I)
if (!LiveSet.count(*I)) // Is this instruction alive?
(*I)->dropAllReferences(); // Nope, drop references...
}
} }
cerr << "Before Deleting Blocks: " << Func; // Loop over all of the basic blocks in the function, removing dead
// instructions from alive blocks, and dropping references of the dead blocks
//
for (Function::iterator I = Func->begin(), E = Func->end(); I != E; ++I) {
BasicBlock *BB = *I;
if (AliveBlocks.count(BB)) {
for (BasicBlock::iterator II = BB->begin(); II != BB->end()-1; )
if (!LiveSet.count(*II)) { // Is this instruction alive?
// Nope... remove the instruction from it's basic block...
delete BB->getInstList().remove(II);
++NumInstRemoved;
MadeChanges = true;
} else {
++II;
}
} else {
// Remove all outgoing edges from this basic block and convert the
// terminator into a return instruction.
vector<BasicBlock*> Succs(succ_begin(BB), succ_end(BB));
if (!Succs.empty()) {
// Loop over all of the successors, removing this block from PHI node
// entries that might be in the block...
while (!Succs.empty()) {
Succs.back()->removePredecessor(BB);
Succs.pop_back();
}
// Delete the old terminator instruction...
delete BB->getInstList().remove(BB->end()-1);
const Type *RetTy = Func->getReturnType();
Instruction *New = new ReturnInst(RetTy != Type::VoidTy ?
Constant::getNullValue(RetTy) : 0);
BB->getInstList().push_back(New);
}
BB->dropAllReferences();
++NumBlockRemoved;
MadeChanges = true;
}
}
// Now loop through all of the blocks and delete them. We can safely do this // Now loop through all of the blocks and delete them. We can safely do this
// now because we know that there are no references to dead blocks (because // now because we know that there are no references to dead blocks (because
// they have dropped all of their references... // they have dropped all of their references...
// //
for (Function::iterator BI = Func->begin(); BI != Func->end();) { for (Function::iterator BI = Func->begin(); BI != Func->end(); )
if (!AliveBlocks.count(*BI)) { if (!AliveBlocks.count(*BI))
delete Func->getBasicBlocks().remove(BI); delete Func->getBasicBlocks().remove(BI);
MadeChanges = true; else
continue; // Don't increment iterator ++BI; // Increment iterator...
}
++BI; // Increment iterator...
}
if (EntryBlock && EntryBlock != Func->front()) { return MadeChanges;
// We need to move the new entry block to be the first bb of the function
Function::iterator EBI = find(Func->begin(), Func->end(), EntryBlock);
std::swap(*EBI, *Func->begin()); // Exchange old location with start of fn
}
while (PHINode *PN = dyn_cast<PHINode>(EntryBlock->front())) {
assert(PN->getNumIncomingValues() == 1 &&
"Can only have a single incoming value at this point...");
// The incoming value must be outside of the scope of the function, a
// global variable, constant or parameter maybe...
//
PN->replaceAllUsesWith(PN->getIncomingValue(0));
// Nuke the phi node...
delete EntryBlock->getInstList().remove(EntryBlock->begin());
}
} }
// fixupCFG - Walk the CFG in depth first order, eliminating references to
// dead blocks:
// If the BB is alive (in AliveBlocks):
// 1. Eliminate all dead instructions in the BB
// 2. Recursively traverse all of the successors of the BB:
// - If the returned successor is non-null, update our terminator to
// reference the returned BB
// 3. Return 0 (no update needed)
//
// If the BB is dead (not in AliveBlocks):
// 1. Add the BB to the dead set
// 2. Recursively traverse all of the successors of the block:
// - Only one shall return a nonnull value (or else this block should have
// been in the alive set).
// 3. Return the nonnull child, or 0 if no non-null children.
//
BasicBlock *ADCE::fixupCFG(BasicBlock *BB, std::set<BasicBlock*> &VisitedBlocks,
const std::set<BasicBlock*> &AliveBlocks) {
if (VisitedBlocks.count(BB)) return 0; // Revisiting a node? No update.
VisitedBlocks.insert(BB); // We have now visited this node!
DEBUG(cerr << "Fixing up BB: " << BB);
if (AliveBlocks.count(BB)) { // Is the block alive?
// Yes it's alive: loop through and eliminate all dead instructions in block
for (BasicBlock::iterator II = BB->begin(); II != BB->end()-1; )
if (!LiveSet.count(*II)) { // Is this instruction alive?
// Nope... remove the instruction from it's basic block...
delete BB->getInstList().remove(II);
MadeChanges = true;
} else {
++II;
}
// Recursively traverse successors of this basic block.
for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI) {
BasicBlock *Succ = *SI;
BasicBlock *Repl = fixupCFG(Succ, VisitedBlocks, AliveBlocks);
if (Repl && Repl != Succ) { // We have to replace the successor
Succ->replaceAllUsesWith(Repl);
MadeChanges = true;
}
}
return BB;
} else { // Otherwise the block is dead...
BasicBlock *ReturnBB = 0; // Default to nothing live down here
// Recursively traverse successors of this basic block.
for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI) {
BasicBlock *RetBB = fixupCFG(*SI, VisitedBlocks, AliveBlocks);
if (RetBB) {
assert(ReturnBB == 0 && "At most one live child allowed!");
ReturnBB = RetBB;
}
}
return ReturnBB; // Return the result of traversal
}
}