From 3481f24c06b3c9de48bdd99c37547471ca8e761e Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Thu, 27 Nov 2008 22:57:53 +0000 Subject: [PATCH] remove doConstantPropagation and dceInstruction, they are just wrappers around the interesting code and use an obscure iterator abstraction that dates back many many years. Move EraseDeadInstructions to Transforms/Utils and name it RecursivelyDeleteTriviallyDeadInstructions. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60191 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Transforms/Utils/Local.h | 23 ++++------ lib/Transforms/Scalar/CodeGenPrepare.cpp | 22 +--------- 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 42927297565..65438aa5e4a 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 9bf39911b6c..e6b7497d6bc 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(V); - if (!I || !I->use_empty()) return; - - SmallPtrSet 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(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 efb902267d9..e3a0917eb02 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 +#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(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(V); + if (!I || !I->use_empty()) return; + + SmallPtrSet 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(I->getOperand(i))) + Insts.insert(U); + I->eraseFromParent(); + } } - return false; } + //===----------------------------------------------------------------------===// // Control Flow Graph Restructuring... //