From 59b6b8e0b3e51dd899da25bd25b0793cc8229eea Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 21 Jan 2002 23:17:48 +0000 Subject: Move stuff out of the Optimizations directories into the appropriate Transforms directories. Eliminate the opt namespace. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1520 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/Expressions.cpp | 3 +-- lib/Makefile | 2 +- lib/Transforms/ExprTypeConvert.cpp | 8 ++++---- lib/Transforms/IPO/InlineSimple.cpp | 17 +++++++---------- lib/Transforms/LevelRaise.cpp | 10 +++++----- lib/Transforms/Scalar/ADCE.cpp | 4 ++-- lib/Transforms/Scalar/ConstantProp.cpp | 25 +++++++++++-------------- lib/Transforms/Scalar/DCE.cpp | 16 ++++++++-------- lib/Transforms/Scalar/InductionVars.cpp | 2 +- lib/Transforms/Scalar/InstructionCombining.cpp | 6 ++---- lib/Transforms/Scalar/SCCP.cpp | 19 +++++++++---------- lib/Transforms/Scalar/SymbolStripping.cpp | 6 +++--- lib/VMCore/ConstantFold.cpp | 2 +- 13 files changed, 55 insertions(+), 65 deletions(-) (limited to 'lib') diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp index e94c796059..8fdfba6ada 100644 --- a/lib/Analysis/Expressions.cpp +++ b/lib/Analysis/Expressions.cpp @@ -8,12 +8,11 @@ //===----------------------------------------------------------------------===// #include "llvm/Analysis/Expressions.h" -#include "llvm/Optimizations/ConstantHandling.h" +#include "llvm/Transforms/Scalar/ConstantHandling.h" #include "llvm/Method.h" #include "llvm/BasicBlock.h" #include -using namespace opt; // Get all the constant handling stuff using namespace analysis; ExprType::ExprType(Value *Val) { diff --git a/lib/Makefile b/lib/Makefile index 5ff4f16e62..3ec7771700 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -1,5 +1,5 @@ LEVEL = .. -DIRS = VMCore Analysis Transforms Assembly Bytecode Optimizations Support CodeGen Target +DIRS = VMCore Analysis Transforms Assembly Bytecode Support CodeGen Target include $(LEVEL)/Makefile.common diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 7f33fe280b..d75a8ac68c 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -12,8 +12,8 @@ #include "llvm/iPHINode.h" #include "llvm/iMemory.h" #include "llvm/ConstantVals.h" -#include "llvm/Optimizations/ConstantHandling.h" -#include "llvm/Optimizations/DCE.h" +#include "llvm/Transforms/Scalar/ConstantHandling.h" +#include "llvm/Transforms/Scalar/DCE.h" #include "llvm/Analysis/Expressions.h" #include "Support/STLExtras.h" #include @@ -190,7 +190,7 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, // it can convert the value... // if (Constant *CPV = dyn_cast(V)) - if (opt::ConstantFoldCastInstruction(CPV, Ty)) + if (ConstantFoldCastInstruction(CPV, Ty)) return true; // Don't worry about deallocating, it's a constant. return false; // Otherwise, we can't convert! @@ -369,7 +369,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { if (Constant *CPV = cast(V)) { // Constants are converted by constant folding the cast that is required. // We assume here that all casts are implemented for constant prop. - Value *Result = opt::ConstantFoldCastInstruction(CPV, Ty); + Value *Result = ConstantFoldCastInstruction(CPV, Ty); assert(Result && "ConstantFoldCastInstruction Failed!!!"); assert(Result->getType() == Ty && "Const prop of cast failed!"); diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index 9d86c86895..a71acd2a79 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -9,17 +9,16 @@ // . Has a smart heuristic for when to inline a method // // Notice that: -// * This pass has a habit of introducing duplicated constant pool entries, -// and also opens up a lot of opportunities for constant propogation. It is -// a good idea to to run a constant propogation pass, then a DCE pass +// * This pass opens up a lot of opportunities for constant propogation. It +// is a good idea to to run a constant propogation pass, then a DCE pass // sometime after running this pass. // // TODO: Currently this throws away all of the symbol names in the method being -// inlined to try to avoid name clashes. Use a name if it's not taken +// inlined. This shouldn't happen. // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/MethodInlining.h" +#include "llvm/Transforms/MethodInlining.h" #include "llvm/Module.h" #include "llvm/Method.h" #include "llvm/iTerminators.h" @@ -32,8 +31,6 @@ using std::cerr; #include "llvm/Assembly/Writer.h" -using namespace opt; - // RemapInstruction - Convert the instruction operands from referencing the // current values into those specified by ValueMap. // @@ -65,7 +62,7 @@ static inline void RemapInstruction(Instruction *I, // exists in the instruction stream. Similiarly this will inline a recursive // method by one level. // -bool opt::InlineMethod(BasicBlock::iterator CIIt) { +bool InlineMethod(BasicBlock::iterator CIIt) { assert(isa(*CIIt) && "InlineMethod only works on CallInst nodes!"); assert((*CIIt)->getParent() && "Instruction not embedded in basic block!"); assert((*CIIt)->getParent()->getParent() && "Instruction not in method!"); @@ -207,7 +204,7 @@ bool opt::InlineMethod(BasicBlock::iterator CIIt) { return true; } -bool opt::InlineMethod(CallInst *CI) { +bool InlineMethod(CallInst *CI) { assert(CI->getParent() && "CallInst not embeded in BasicBlock!"); BasicBlock *PBB = CI->getParent(); @@ -248,7 +245,7 @@ static inline bool DoMethodInlining(BasicBlock *BB) { return false; } -bool opt::MethodInlining::doMethodInlining(Method *M) { +bool MethodInlining::doMethodInlining(Method *M) { bool Changed = false; // Loop through now and inline instructions a basic block at a time... diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp index f140676937..38865003bb 100644 --- a/lib/Transforms/LevelRaise.cpp +++ b/lib/Transforms/LevelRaise.cpp @@ -12,9 +12,9 @@ #include "llvm/iOther.h" #include "llvm/iMemory.h" #include "llvm/ConstantVals.h" -#include "llvm/Optimizations/ConstantHandling.h" -#include "llvm/Optimizations/DCE.h" -#include "llvm/Optimizations/ConstantProp.h" +#include "llvm/Transforms/Scalar/DCE.h" +#include "llvm/Transforms/Scalar/ConstantHandling.h" +#include "llvm/Transforms/Scalar/ConstantProp.h" #include "llvm/Analysis/Expressions.h" #include "Support/STLExtras.h" #include @@ -413,8 +413,8 @@ static bool DoRaisePass(Method *M) { #if DEBUG_PEEPHOLE_INSTS cerr << "Processing: " << *BI; #endif - if (opt::DeadCodeElimination::dceInstruction(BIL, BI) || - opt::ConstantPropogation::doConstantPropogation(BB, BI)) { + if (DeadCodeElimination::dceInstruction(BIL, BI) || + ConstantPropogation::doConstantPropogation(BB, BI)) { Changed = true; #ifdef DEBUG_PEEPHOLE_INSTS cerr << "DeadCode Elinated!\n"; diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp index 45a57a2f43..01046b0033 100644 --- a/lib/Transforms/Scalar/ADCE.cpp +++ b/lib/Transforms/Scalar/ADCE.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/DCE.h" +#include "llvm/Transforms/Scalar/DCE.h" #include "llvm/Instruction.h" #include "llvm/Type.h" #include "llvm/Analysis/Dominators.h" @@ -297,7 +297,7 @@ BasicBlock *ADCE::fixupCFG(BasicBlock *BB, std::set &VisitedBlocks, // doADCE - Execute the Agressive Dead Code Elimination Algorithm // -bool opt::AgressiveDCE::doADCE(Method *M) { +bool AgressiveDCE::doADCE(Method *M) { if (M->isExternal()) return false; ADCE DCE(M); return DCE.doADCE(); diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp index a961bad927..190bd4b919 100644 --- a/lib/Transforms/Scalar/ConstantProp.cpp +++ b/lib/Transforms/Scalar/ConstantProp.cpp @@ -21,8 +21,8 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/ConstantProp.h" -#include "llvm/Optimizations/ConstantHandling.h" +#include "llvm/Transforms/Scalar/ConstantProp.h" +#include "llvm/Transforms/Scalar/ConstantHandling.h" #include "llvm/Module.h" #include "llvm/Method.h" #include "llvm/BasicBlock.h" @@ -34,8 +34,7 @@ inline static bool ConstantFoldUnaryInst(BasicBlock *BB, BasicBlock::iterator &II, UnaryOperator *Op, Constant *D) { - Constant *ReplaceWith = - opt::ConstantFoldUnaryInstruction(Op->getOpcode(), D); + Constant *ReplaceWith = ConstantFoldUnaryInstruction(Op->getOpcode(), D); if (!ReplaceWith) return false; // Nothing new to change... @@ -57,8 +56,7 @@ ConstantFoldUnaryInst(BasicBlock *BB, BasicBlock::iterator &II, inline static bool ConstantFoldCast(BasicBlock *BB, BasicBlock::iterator &II, CastInst *CI, Constant *D) { - Constant *ReplaceWith = - opt::ConstantFoldCastInstruction(D, CI->getType()); + Constant *ReplaceWith = ConstantFoldCastInstruction(D, CI->getType()); if (!ReplaceWith) return false; // Nothing new to change... @@ -81,8 +79,7 @@ inline static bool ConstantFoldBinaryInst(BasicBlock *BB, BasicBlock::iterator &II, BinaryOperator *Op, Constant *D1, Constant *D2) { - Constant *ReplaceWith = - opt::ConstantFoldBinaryInstruction(Op->getOpcode(), D1, D2); + Constant *ReplaceWith = ConstantFoldBinaryInstruction(Op->getOpcode(), D1,D2); if (!ReplaceWith) return false; // Nothing new to change... // Replaces all of the uses of a variable with uses of the constant. @@ -104,7 +101,7 @@ ConstantFoldBinaryInst(BasicBlock *BB, BasicBlock::iterator &II, // constant value, convert it into an unconditional branch to the constant // destination. // -bool opt::ConstantFoldTerminator(TerminatorInst *T) { +bool ConstantFoldTerminator(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 @@ -156,8 +153,8 @@ bool opt::ConstantFoldTerminator(TerminatorInst *T) { // ConstantFoldInstruction - If an instruction references constants, try to fold // them together... // -bool opt::ConstantPropogation::doConstantPropogation(BasicBlock *BB, - BasicBlock::iterator &II) { +bool ConstantPropogation::doConstantPropogation(BasicBlock *BB, + BasicBlock::iterator &II) { Instruction *Inst = *II; if (isa(Inst)) { Constant *D1 = dyn_cast(Inst->getOperand(0)); @@ -174,7 +171,7 @@ bool opt::ConstantPropogation::doConstantPropogation(BasicBlock *BB, Constant *D = dyn_cast(UInst->getOperand(0)); if (D) return ConstantFoldUnaryInst(BB, II, UInst, D); } else if (TerminatorInst *TInst = dyn_cast(Inst)) { - return opt::ConstantFoldTerminator(TInst); + return ConstantFoldTerminator(TInst); } else if (PHINode *PN = dyn_cast(Inst)) { // If it's a PHI node and only has one operand @@ -203,7 +200,7 @@ static bool DoConstPropPass(Method *M) { for (Method::iterator BBI = M->begin(); BBI != M->end(); ++BBI) { BasicBlock *BB = *BBI; for (BasicBlock::iterator I = BB->begin(); I != BB->end(); ) - if (opt::ConstantPropogation::doConstantPropogation(BB, I)) + if (ConstantPropogation::doConstantPropogation(BB, I)) SomethingChanged = true; else ++I; @@ -214,7 +211,7 @@ static bool DoConstPropPass(Method *M) { // returns whether or not the underlying method was modified // -bool opt::ConstantPropogation::doConstantPropogation(Method *M) { +bool ConstantPropogation::doConstantPropogation(Method *M) { bool Modified = false; // Fold constants until we make no progress... diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp index eadf7b18e0..218c0add8b 100644 --- a/lib/Transforms/Scalar/DCE.cpp +++ b/lib/Transforms/Scalar/DCE.cpp @@ -23,7 +23,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/DCE.h" +#include "llvm/Transforms/Scalar/DCE.h" #include "llvm/Module.h" #include "llvm/GlobalVariable.h" #include "llvm/Method.h" @@ -39,8 +39,8 @@ // to point to the instruction that immediately succeeded the original // instruction. // -bool opt::DeadCodeElimination::dceInstruction(BasicBlock::InstListType &BBIL, - BasicBlock::iterator &BBI) { +bool DeadCodeElimination::dceInstruction(BasicBlock::InstListType &BBIL, + BasicBlock::iterator &BBI) { // Look for un"used" definitions... if ((*BBI)->use_empty() && !(*BBI)->hasSideEffects() && !isa(*BBI)) { @@ -54,7 +54,7 @@ static inline bool RemoveUnusedDefs(BasicBlock::InstListType &Vals) { bool Changed = false; for (BasicBlock::InstListType::iterator DI = Vals.begin(); DI != Vals.end(); ) - if (opt::DeadCodeElimination::dceInstruction(Vals, DI)) + if (DeadCodeElimination::dceInstruction(Vals, DI)) Changed = true; else ++DI; @@ -155,7 +155,7 @@ static bool PropogatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) { // // WARNING: The entry node of a method may not be simplified. // -bool opt::SimplifyCFG(Method::iterator &BBIt) { +bool SimplifyCFG(Method::iterator &BBIt) { BasicBlock *BB = *BBIt; Method *M = BB->getParent(); @@ -282,7 +282,7 @@ static bool DoDCEPass(Method *M) { // if they are unneeded... // for (BBIt = M->begin(), ++BBIt; BBIt != M->end(); ) { - if (opt::SimplifyCFG(BBIt)) { + if (SimplifyCFG(BBIt)) { Changed = true; } else { ++BBIt; @@ -296,13 +296,13 @@ static bool DoDCEPass(Method *M) { // It is possible that we may require multiple passes over the code to fully // eliminate dead code. Iterate until we are done. // -bool opt::DeadCodeElimination::doDCE(Method *M) { +bool DeadCodeElimination::doDCE(Method *M) { bool Changed = false; while (DoDCEPass(M)) Changed = true; return Changed; } -bool opt::DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) { +bool DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) { bool Changed = false; for (Module::iterator MI = Mod->begin(); MI != Mod->end(); ) { diff --git a/lib/Transforms/Scalar/InductionVars.cpp b/lib/Transforms/Scalar/InductionVars.cpp index 93ab189dee..cab778e025 100644 --- a/lib/Transforms/Scalar/InductionVars.cpp +++ b/lib/Transforms/Scalar/InductionVars.cpp @@ -19,7 +19,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/InductionVars.h" +#include "llvm/Transforms/Scalar/InductionVars.h" #include "llvm/ConstantVals.h" #include "llvm/Analysis/IntervalPartition.h" #include "llvm/Assembly/Writer.h" diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 795418f939..25590661b7 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -15,12 +15,10 @@ //===----------------------------------------------------------------------===// #include "llvm/Transforms/Scalar/InstructionCombining.h" -#include "../TransformInternals.h" -#include "llvm/Optimizations/ConstantHandling.h" +#include "llvm/Transforms/Scalar/ConstantHandling.h" #include "llvm/Method.h" #include "llvm/iMemory.h" - -using namespace opt; +#include "../TransformInternals.h" static Instruction *CombineBinOp(BinaryOperator *I) { bool Changed = false; diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 68be844095..9b2343c936 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -15,8 +15,8 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/ConstantProp.h" -#include "llvm/Optimizations/ConstantHandling.h" +#include "llvm/Transforms/Scalar/ConstantProp.h" +#include "llvm/Transforms/Scalar/ConstantHandling.h" #include "llvm/Method.h" #include "llvm/BasicBlock.h" #include "llvm/ConstantVals.h" @@ -273,7 +273,7 @@ bool SCCP::doSCCP() { MadeChanges = true; continue; // Skip the ++II at the end of the loop here... } else if (Inst->isTerminator()) { - MadeChanges |= opt::ConstantFoldTerminator(cast(Inst)); + MadeChanges |= ConstantFoldTerminator(cast(Inst)); } ++II; @@ -446,9 +446,8 @@ void SCCP::UpdateInstruction(Instruction *I) { markOverdefined(I); } else if (VState.isConstant()) { // Propogate constant value Constant *Result = isa(I) - ? opt::ConstantFoldCastInstruction(VState.getConstant(), I->getType()) - : opt::ConstantFoldUnaryInstruction(I->getOpcode(), - VState.getConstant()); + ? ConstantFoldCastInstruction(VState.getConstant(), I->getType()) + : ConstantFoldUnaryInstruction(I->getOpcode(), VState.getConstant()); if (Result) { // This instruction constant folds! @@ -473,9 +472,9 @@ void SCCP::UpdateInstruction(Instruction *I) { markOverdefined(I); } else if (V1State.isConstant() && V2State.isConstant()) { Constant *Result = - opt::ConstantFoldBinaryInstruction(I->getOpcode(), - V1State.getConstant(), - V2State.getConstant()); + ConstantFoldBinaryInstruction(I->getOpcode(), + V1State.getConstant(), + V2State.getConstant()); if (Result) { // This instruction constant folds! markConstant(I, Result); @@ -511,7 +510,7 @@ void SCCP::OperandChangedState(User *U) { // DoSparseConditionalConstantProp - Use Sparse Conditional Constant Propogation // to prove whether a value is constant and whether blocks are used. // -bool opt::SCCPPass::doSCCP(Method *M) { +bool SCCPPass::doSCCP(Method *M) { if (M->isExternal()) return false; SCCP S(M); return S.doSCCP(); diff --git a/lib/Transforms/Scalar/SymbolStripping.cpp b/lib/Transforms/Scalar/SymbolStripping.cpp index 417376b89d..12f8e918b3 100644 --- a/lib/Transforms/Scalar/SymbolStripping.cpp +++ b/lib/Transforms/Scalar/SymbolStripping.cpp @@ -14,7 +14,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/AllOpts.h" +#include "llvm/Transforms/SymbolStripping.h" #include "llvm/Module.h" #include "llvm/Method.h" #include "llvm/SymbolTable.h" @@ -44,14 +44,14 @@ static bool StripSymbolTable(SymbolTable *SymTab) { // DoSymbolStripping - Remove all symbolic information from a method // -bool opt::SymbolStripping::doSymbolStripping(Method *M) { +bool SymbolStripping::doSymbolStripping(Method *M) { return StripSymbolTable(M->getSymbolTable()); } // doStripGlobalSymbols - Remove all symbolic information from all methods // in a module, and all module level symbols. (method names, etc...) // -bool opt::FullSymbolStripping::doStripGlobalSymbols(Module *M) { +bool FullSymbolStripping::doStripGlobalSymbols(Module *M) { // Remove all symbols from methods in this module... and then strip all of the // symbols in this module... // diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index fa561de6a3..80374f339c 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -4,7 +4,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Optimizations/ConstantHandling.h" +#include "llvm/Transforms/Scalar/ConstantHandling.h" AnnotationID ConstRules::AID(AnnotationManager::getID("opt::ConstRules", &ConstRules::find)); -- cgit v1.2.3