diff options
| -rw-r--r-- | include/llvm/Transforms/Utils/Local.h | 23 | ||||
| -rw-r--r-- | lib/Transforms/Scalar/CodeGenPrepare.cpp | 22 | ||||
| -rw-r--r-- | lib/Transforms/Utils/Local.cpp | 55 |
3 files changed, 34 insertions, 66 deletions
diff --git a/include/llvm/Transforms/Utils/Local.h b/include/llvm/Transforms/Utils/Local.h index 4292729..65438aa 100644 --- a/include/llvm/Transforms/Utils/Local.h +++ b/include/llvm/Transforms/Utils/Local.h @@ -26,14 +26,9 @@ class ConstantExpr; class TargetData; //===----------------------------------------------------------------------===// -// Local constant propagation... +// Local constant propagation. // -/// doConstantPropagation - Constant prop a specific instruction. Returns true -/// and potentially moves the iterator if constant propagation was performed. -/// -bool doConstantPropagation(BasicBlock::iterator &I, const TargetData *TD = 0); - /// ConstantFoldTerminator - If a terminator instruction is predicated on a /// constant value, convert it into an unconditional branch to the constant /// destination. This is a nontrivial operation because the successors of this @@ -42,7 +37,7 @@ bool doConstantPropagation(BasicBlock::iterator &I, const TargetData *TD = 0); bool ConstantFoldTerminator(BasicBlock *BB); //===----------------------------------------------------------------------===// -// Local dead code elimination... +// Local dead code elimination. // /// isInstructionTriviallyDead - Return true if the result produced by the @@ -50,14 +45,12 @@ bool ConstantFoldTerminator(BasicBlock *BB); /// bool isInstructionTriviallyDead(Instruction *I); - -/// dceInstruction - Inspect the instruction at *BBI and figure out if it -/// isTriviallyDead. If so, remove the instruction and update the iterator to -/// point to the instruction that immediately succeeded the original -/// instruction. -/// -bool dceInstruction(BasicBlock::iterator &BBI); - + +/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a +/// trivially dead instruction, delete it. If that makes any of its operands +/// trivially dead, delete them too, recursively. +void RecursivelyDeleteTriviallyDeadInstructions(Value *V); + //===----------------------------------------------------------------------===// // Control Flow Graph Restructuring... // diff --git a/lib/Transforms/Scalar/CodeGenPrepare.cpp b/lib/Transforms/Scalar/CodeGenPrepare.cpp index 9bf3991..e6b7497 100644 --- a/lib/Transforms/Scalar/CodeGenPrepare.cpp +++ b/lib/Transforms/Scalar/CodeGenPrepare.cpp @@ -454,26 +454,6 @@ static bool OptimizeCmpExpression(CmpInst *CI) { return MadeChange; } -/// EraseDeadInstructions - Erase any dead instructions, recursively. -static void EraseDeadInstructions(Value *V) { - Instruction *I = dyn_cast<Instruction>(V); - if (!I || !I->use_empty()) return; - - SmallPtrSet<Instruction*, 16> Insts; - Insts.insert(I); - - while (!Insts.empty()) { - I = *Insts.begin(); - Insts.erase(I); - if (isInstructionTriviallyDead(I)) { - for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) - if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i))) - Insts.insert(U); - I->eraseFromParent(); - } - } -} - //===----------------------------------------------------------------------===// // Addressing Mode Analysis and Optimization //===----------------------------------------------------------------------===// @@ -1234,7 +1214,7 @@ bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr, MemoryInst->replaceUsesOfWith(Addr, SunkAddr); if (Addr->use_empty()) - EraseDeadInstructions(Addr); + RecursivelyDeleteTriviallyDeadInstructions(Addr); return true; } diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp index efb9022..e3a0917 100644 --- a/lib/Transforms/Utils/Local.cpp +++ b/lib/Transforms/Utils/Local.cpp @@ -22,30 +22,13 @@ #include "llvm/Target/TargetData.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/MathExtras.h" -#include <cerrno> +#include "llvm/ADT/SmallPtrSet.h" using namespace llvm; //===----------------------------------------------------------------------===// -// Local constant propagation... +// Local constant propagation. // -/// doConstantPropagation - If an instruction references constants, try to fold -/// them together... -/// -bool llvm::doConstantPropagation(BasicBlock::iterator &II, - const TargetData *TD) { - if (Constant *C = ConstantFoldInstruction(II, TD)) { - // Replaces all of the uses of a variable with uses of the constant. - II->replaceAllUsesWith(C); - - // Remove the instruction from the basic block... - II = II->getParent()->getInstList().erase(II); - return true; - } - - return false; -} - // ConstantFoldTerminator - If a terminator instruction is predicated on a // constant value, convert it into an unconditional branch to the constant // destination. @@ -171,6 +154,9 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB) { // Local dead code elimination... // +/// isInstructionTriviallyDead - Return true if the result produced by the +/// instruction is not used, and the instruction has no side effects. +/// bool llvm::isInstructionTriviallyDead(Instruction *I) { if (!I->use_empty() || isa<TerminatorInst>(I)) return false; @@ -187,20 +173,29 @@ bool llvm::isInstructionTriviallyDead(Instruction *I) { return false; } -// dceInstruction - Inspect the instruction at *BBI and figure out if it's -// [trivially] dead. If so, remove the instruction and update the iterator -// to point to the instruction that immediately succeeded the original -// instruction. -// -bool llvm::dceInstruction(BasicBlock::iterator &BBI) { - // Look for un"used" definitions... - if (isInstructionTriviallyDead(BBI)) { - BBI = BBI->getParent()->getInstList().erase(BBI); // Bye bye - return true; +/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a +/// trivially dead instruction, delete it. If that makes any of its operands +/// trivially dead, delete them too, recursively. +void llvm::RecursivelyDeleteTriviallyDeadInstructions(Value *V) { + Instruction *I = dyn_cast<Instruction>(V); + if (!I || !I->use_empty()) return; + + SmallPtrSet<Instruction*, 16> Insts; + Insts.insert(I); + + while (!Insts.empty()) { + I = *Insts.begin(); + Insts.erase(I); + if (isInstructionTriviallyDead(I)) { + for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) + if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i))) + Insts.insert(U); + I->eraseFromParent(); + } } - return false; } + //===----------------------------------------------------------------------===// // Control Flow Graph Restructuring... // |