From 2ed01d8f0bdb8aa73d893a8beb23b1838422fa32 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 7 May 2002 18:10:55 +0000 Subject: [PATCH] Factor code out to the TransformUtils library git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2516 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Scalar/ConstantProp.cpp | 82 +------------------------- lib/Transforms/Scalar/DCE.cpp | 25 +------- 2 files changed, 5 insertions(+), 102 deletions(-) diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp index b43f23745aa..7085ef98006 100644 --- a/lib/Transforms/Scalar/ConstantProp.cpp +++ b/lib/Transforms/Scalar/ConstantProp.cpp @@ -12,91 +12,13 @@ //===----------------------------------------------------------------------===// #include "llvm/Transforms/Scalar/ConstantProp.h" +#include "llvm/Transforms/Utils/Local.h" #include "llvm/ConstantHandling.h" -#include "llvm/Function.h" -#include "llvm/BasicBlock.h" -#include "llvm/iTerminators.h" +#include "llvm/Instruction.h" #include "llvm/Pass.h" #include "llvm/Support/InstIterator.h" #include -// FIXME: ConstantFoldInstruction & ConstantFoldTerminator should be moved out -// to the Transformations library. - -// ConstantFoldInstruction - If an instruction references constants, try to fold -// them together... -// -bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &II) { - Instruction *Inst = *II; - if (Constant *C = ConstantFoldInstruction(Inst)) { - // Replaces all of the uses of a variable with uses of the constant. - Inst->replaceAllUsesWith(C); - - // Remove the instruction from the basic block... - delete BB->getInstList().remove(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. -// -bool ConstantFoldTerminator(BasicBlock *BB, BasicBlock::iterator &II, - TerminatorInst *T) { - // Branch - See if we are conditional jumping on constant - if (BranchInst *BI = dyn_cast(T)) { - if (BI->isUnconditional()) return false; // Can't optimize uncond branch - BasicBlock *Dest1 = cast(BI->getOperand(0)); - BasicBlock *Dest2 = cast(BI->getOperand(1)); - - if (ConstantBool *Cond = dyn_cast(BI->getCondition())) { - // Are we branching on constant? - // YES. Change to unconditional branch... - BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2; - BasicBlock *OldDest = Cond->getValue() ? Dest2 : Dest1; - - //cerr << "Function: " << T->getParent()->getParent() - // << "\nRemoving branch from " << T->getParent() - // << "\n\nTo: " << OldDest << endl; - - // Let the basic block know that we are letting go of it. Based on this, - // it will adjust it's PHI nodes. - assert(BI->getParent() && "Terminator not inserted in block!"); - OldDest->removePredecessor(BI->getParent()); - - // Set the unconditional destination, and change the insn to be an - // unconditional branch. - BI->setUnconditionalDest(Destination); - II = BB->end()-1; // Update instruction iterator! - return true; - } -#if 0 - // FIXME: TODO: This doesn't work if the destination has PHI nodes with - // different incoming values on each branch! - // - else if (Dest2 == Dest1) { // Conditional branch to same location? - // This branch matches something like this: - // br bool %cond, label %Dest, label %Dest - // and changes it into: br label %Dest - - // Let the basic block know that we are letting go of one copy of it. - assert(BI->getParent() && "Terminator not inserted in block!"); - Dest1->removePredecessor(BI->getParent()); - - // Change a conditional branch to unconditional. - BI->setUnconditionalDest(Dest1); - return true; - } -#endif - } - return false; -} - - - namespace { struct ConstantPropogation : public FunctionPass { const char *getPassName() const { return "Simple Constant Propogation"; } diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp index 5983910c182..ec9a387c18f 100644 --- a/lib/Transforms/Scalar/DCE.cpp +++ b/lib/Transforms/Scalar/DCE.cpp @@ -10,31 +10,12 @@ //===----------------------------------------------------------------------===// #include "llvm/Transforms/Scalar/DCE.h" +#include "llvm/Transforms/Utils/Local.h" +#include "llvm/Instruction.h" #include "llvm/Pass.h" -#include "llvm/InstrTypes.h" -#include "llvm/Function.h" #include "llvm/Support/InstIterator.h" #include -static inline bool isInstDead(Instruction *I) { - return I->use_empty() && !I->hasSideEffects() && !isa(I); -} - -// 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 dceInstruction(BasicBlock::InstListType &BBIL, - BasicBlock::iterator &BBI) { - // Look for un"used" definitions... - if (isInstDead(*BBI)) { - delete BBIL.remove(BBI); // Bye bye - return true; - } - return false; -} - //===----------------------------------------------------------------------===// // DeadInstElimination pass implementation // @@ -95,7 +76,7 @@ bool DCE::runOnFunction(Function *F) { Instruction *I = WorkList.back(); WorkList.pop_back(); - if (isInstDead(I)) { // If the instruction is dead... + 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. -- 2.34.1