//===- DCE.cpp - Code to perform dead code elimination --------------------===//
//
-// This file implements dead code elimination and basic block merging.
+// This file implements dead inst elimination and dead code elimination.
//
-// Specifically, this:
-// * removes definitions with no uses (including unused constants)
-// * removes basic blocks with no predecessors
-// * merges a basic block into its predecessor if there is only one and the
-// predecessor only has one successor.
-//
-// TODO: This should REALLY be recursive instead of iterative. Right now, we
-// scan linearly through values, removing unused ones as we go. The problem is
-// that this may cause other earlier values to become unused. To make sure that
-// we get them all, we iterate until things stop changing. Instead, when
-// removing a value, recheck all of its operands to see if they are now unused.
-// Piece of cake, and more efficient as well.
+// Dead Inst Elimination performs a single pass over the function removing
+// instructions that are obviously dead. Dead Code Elimination is similar, but
+// it rechecks instructions that were used by removed instructions to see if
+// they are newly dead.
//
//===----------------------------------------------------------------------===//
-#include "llvm/Module.h"
-#include "llvm/Method.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/iTerminators.h"
-#include "llvm/Opt/AllOpts.h"
-
-struct ConstPoolDCE {
- enum { EndOffs = 0 };
- static bool isDCEable(const Value *) { return true; }
-};
-
-struct BasicBlockDCE {
- enum { EndOffs = 1 };
- static bool isDCEable(const Instruction *I) {
- return !I->hasSideEffects();
- }
-};
-
-template<class ValueSubclass, class ItemParentType, class DCEController>
-static bool RemoveUnusedDefs(ValueHolder<ValueSubclass, ItemParentType> &Vals,
- DCEController DCEControl) {
- bool Changed = false;
- typedef ValueHolder<ValueSubclass, ItemParentType> Container;
-
- int Offset = DCEController::EndOffs;
- for (Container::iterator DI = Vals.begin(); DI != Vals.end()-Offset; ) {
- // Look for un"used" definitions...
- if ((*DI)->use_empty() && DCEController::isDCEable(*DI)) {
- // Bye bye
- delete Vals.remove(DI);
- Changed = true;
- } else {
- DI++;
- }
- }
- return Changed;
-}
-
-
-bool DoRemoveUnusedConstants(SymTabValue *S) {
- bool Changed = false;
- ConstantPool &CP = S->getConstantPool();
- for (ConstantPool::plane_iterator PI = CP.begin(); PI != CP.end(); ++PI)
- Changed |= RemoveUnusedDefs(**PI, ConstPoolDCE());
- return Changed;
-}
-
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Utils/Local.h"
+#include "llvm/Instruction.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/InstIterator.h"
+#include "Support/StatisticReporter.h"
+#include <set>
-static void ReplaceUsesWithConstant(Instruction *I) {
- // Get the method level constant pool
- ConstantPool &CP = I->getParent()->getParent()->getConstantPool();
+static Statistic<> DIEEliminated("die\t\t- Number of insts removed");
+static Statistic<> DCEEliminated("dce\t\t- Number of insts removed");
- ConstPoolVal *CPV = 0;
- ConstantPool::PlaneType *P;
- if (!CP.getPlane(I->getType(), P)) { // Does plane exist?
- // Yes, is it empty?
- if (!P->empty()) CPV = P->front();
- }
+//===----------------------------------------------------------------------===//
+// DeadInstElimination pass implementation
+//
- if (CPV == 0) { // We don't have an existing constant to reuse. Just add one.
- CPV = ConstPoolVal::getNullConstant(I->getType()); // Create a new constant
+namespace {
+ struct DeadInstElimination : public BasicBlockPass {
+ virtual bool runOnBasicBlock(BasicBlock &BB) {
+ bool Changed = false;
+ for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); )
+ if (dceInstruction(DI)) {
+ Changed = true;
+ ++DIEEliminated;
+ } else
+ ++DI;
+ return Changed;
+ }
- // Add the new value to the constant pool...
- CP.insert(CPV);
- }
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.preservesCFG();
+ }
+ };
- // Make all users of this instruction reference the constant instead
- I->replaceAllUsesWith(CPV);
+ RegisterOpt<DeadInstElimination> X("die", "Dead Instruction Elimination");
}
-static bool DoDCEPass(Method *M) {
- Method::BasicBlocksType::iterator BBIt;
- Method::BasicBlocksType &BBs = M->getBasicBlocks();
- bool Changed = false;
+Pass *createDeadInstEliminationPass() {
+ return new DeadInstElimination();
+}
- // Loop through now and remove instructions that have no uses...
- for (BBIt = BBs.begin(); BBIt != BBs.end(); BBIt++)
- Changed |= RemoveUnusedDefs((*BBIt)->getInstList(), BasicBlockDCE());
- // Scan through and remove basic blocks that have no predecessors (except,
- // of course, the first one. :) (so skip first block)
- //
- for (BBIt = BBs.begin(), ++BBIt; BBIt != BBs.end(); BBIt++) {
- BasicBlock *BB = *BBIt;
- assert(BB->getTerminator() &&
- "Degenerate basic block encountered!"); // Empty bb???
-
- if (BB->pred_begin() == BB->pred_end() &&
- !BB->hasConstantPoolReferences()) {
-
- while (!BB->getInstList().empty()) {
- Instruction *I = BB->getInstList().front();
- // If this instruction is used, replace uses with an arbitrary
- // constant value. Because control flow can't get here, we don't care
- // what we replace the value with.
- if (!I->use_empty()) ReplaceUsesWithConstant(I);
-
- // Remove the instruction from the basic block
- BasicBlock::InstListType::iterator f = BB->getInstList().begin();
- delete BB->getInstList().remove(f);
- }
- delete BBs.remove(BBIt);
- ++BBIt; // remove puts use on the previous block, we want the next one
- Changed = true;
- }
- }
+//===----------------------------------------------------------------------===//
+// DeadCodeElimination pass implementation
+//
- // Loop through an merge basic blocks into their predecessor if there is only
- // one, and if there is only one successor of the predecessor.
- //
- for (BBIt = BBs.begin(); BBIt != BBs.end(); BBIt++) {
- BasicBlock *BB = *BBIt;
-
- // Is there exactly one predecessor to this block?
- BasicBlock::pred_iterator PI(BB->pred_begin());
- if (PI != BB->pred_end() && ++PI == BB->pred_end() &&
- !BB->hasConstantPoolReferences()) {
- BasicBlock *Pred = *BB->pred_begin();
- TerminatorInst *Term = Pred->getTerminator();
- if (Term == 0) continue; // Err... malformed basic block!
-
- // Is it an unconditional branch?
- if (Term->getInstType() != Instruction::Br ||
- !((BranchInst*)Term)->isUnconditional())
- continue; // Nope, maybe next time...
-
- Changed = true;
-
- // Make all branches to the predecessor now point to the successor...
- Pred->replaceAllUsesWith(BB);
-
- // Move all definitions in the predecessor to the successor...
- BasicBlock::InstListType::iterator DI = Pred->getInstList().end();
- assert(Pred->getTerminator() &&
- "Degenerate basic block encountered!"); // Empty bb???
- delete Pred->getInstList().remove(--DI); // Remove terminator
-
- while (Pred->getInstList().begin() != (DI = Pred->getInstList().end())) {
- Instruction *Def = Pred->getInstList().remove(--DI); // Remove from end
- BB->getInstList().push_front(Def); // Add to front...
- }
+namespace {
+ struct DCE : public FunctionPass {
+ virtual bool runOnFunction(Function &F);
- // Remove basic block from the method...
- BBs.remove(Pred);
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.preservesCFG();
+ }
+ };
- // Always inherit predecessors name if it exists...
- if (Pred->hasName()) BB->setName(Pred->getName());
+ RegisterOpt<DCE> Y("dce", "Dead Code Elimination");
+}
- // So long you waste of a basic block you...
- delete Pred;
+bool DCE::runOnFunction(Function &F) {
+ // Start out with all of the instructions in the worklist...
+ std::vector<Instruction*> WorkList(inst_begin(F), inst_end(F));
+ std::set<Instruction*> DeadInsts;
+
+ // Loop over the worklist finding instructions that are dead. If they are
+ // dead make them drop all of their uses, making other instructions
+ // potentially dead, and work until the worklist is empty.
+ //
+ while (!WorkList.empty()) {
+ Instruction *I = WorkList.back();
+ WorkList.pop_back();
+
+ if (isInstructionTriviallyDead(I)) { // If the instruction is dead...
+ // Loop over all of the values that the instruction uses, if there are
+ // instructions being used, add them to the worklist, because they might
+ // go dead after this one is removed.
+ //
+ for (User::use_iterator UI = I->use_begin(), UE = I->use_end();
+ UI != UE; ++UI)
+ if (Instruction *Used = dyn_cast<Instruction>(*UI))
+ WorkList.push_back(Used);
+
+ // Tell the instruction to let go of all of the values it uses...
+ I->dropAllReferences();
+
+ // Keep track of this instruction, because we are going to delete it later
+ DeadInsts.insert(I);
}
}
- // Remove unused constants
- Changed |= DoRemoveUnusedConstants(M);
- return Changed;
-}
-
+ // If we found no dead instructions, we haven't changed the function...
+ if (DeadInsts.empty()) return false;
+
+ // Otherwise, loop over the program, removing and deleting the instructions...
+ for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
+ for (BasicBlock::iterator BI = I->begin(); BI != I->end(); )
+ if (DeadInsts.count(BI)) { // Is this instruction dead?
+ BI = I->getInstList().erase(BI); // Yup, remove and delete inst
+ ++DCEEliminated;
+ } else { // This instruction is not dead
+ ++BI; // Continue on to the next one...
+ }
-// It is possible that we may require multiple passes over the code to fully
-// eliminate dead code. Iterate until we are done.
-//
-bool DoDeadCodeElimination(Method *M) {
- bool Changed = false;
- while (DoDCEPass(M)) Changed = true;
- return Changed;
+ return true;
}
-bool DoDeadCodeElimination(Module *C) {
- bool Val = ApplyOptToAllMethods(C, DoDeadCodeElimination);
- while (DoRemoveUnusedConstants(C)) Val = true;
- return Val;
+Pass *createDeadCodeEliminationPass() {
+ return new DCE();
}