From: Chris Lattner Date: Mon, 21 Jan 2002 23:17:48 +0000 (+0000) Subject: Move stuff out of the Optimizations directories into the appropriate Transforms X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=59b6b8e0b3e51dd899da25bd25b0793cc8229eea 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 --- diff --git a/include/llvm/Transforms/FunctionInlining.h b/include/llvm/Transforms/FunctionInlining.h index abc08fdbadf..252489749e9 100644 --- a/include/llvm/Transforms/FunctionInlining.h +++ b/include/llvm/Transforms/FunctionInlining.h @@ -11,8 +11,6 @@ #include "llvm/BasicBlock.h" class CallInst; -namespace opt { - struct MethodInlining : public MethodPass { // DoMethodInlining - Use a heuristic based approach to inline methods that // seem to look good. @@ -37,6 +35,4 @@ struct MethodInlining : public MethodPass { bool InlineMethod(CallInst *C); bool InlineMethod(BasicBlock::iterator CI); // *CI must be CallInst -} // end namespace opt - #endif diff --git a/include/llvm/Transforms/Scalar/ConstantProp.h b/include/llvm/Transforms/Scalar/ConstantProp.h index f4418665f9d..d9adf3f399a 100644 --- a/include/llvm/Transforms/Scalar/ConstantProp.h +++ b/include/llvm/Transforms/Scalar/ConstantProp.h @@ -10,8 +10,6 @@ #include "llvm/Pass.h" class TerminatorInst; -namespace opt { - struct ConstantPropogation : public MethodPass { // doConstantPropogation - Do trivial constant propogation and expression // folding @@ -47,6 +45,4 @@ struct SCCPPass : public MethodPass { } }; -} // End Namespace opt - #endif diff --git a/include/llvm/Transforms/Scalar/DCE.h b/include/llvm/Transforms/Scalar/DCE.h index 0e9c620548d..bc498c34a76 100644 --- a/include/llvm/Transforms/Scalar/DCE.h +++ b/include/llvm/Transforms/Scalar/DCE.h @@ -11,8 +11,6 @@ #include "llvm/Pass.h" #include "llvm/BasicBlock.h" -namespace opt { - struct DeadCodeElimination : public MethodPass { // External Interface: // @@ -66,6 +64,4 @@ struct AgressiveDCE : public MethodPass { // bool SimplifyCFG(Method::iterator &BBIt); -} // End namespace opt - #endif diff --git a/include/llvm/Transforms/Scalar/SymbolStripping.h b/include/llvm/Transforms/Scalar/SymbolStripping.h index ff31a4b5323..156e21171f2 100644 --- a/include/llvm/Transforms/Scalar/SymbolStripping.h +++ b/include/llvm/Transforms/Scalar/SymbolStripping.h @@ -10,8 +10,6 @@ #include "llvm/Pass.h" -namespace opt { - struct SymbolStripping : public MethodPass { // doSymbolStripping - Remove all symbolic information from a method // @@ -38,5 +36,4 @@ struct FullSymbolStripping : public MethodPass { } }; -} // End namespace opt #endif diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp index e94c7960596..8fdfba6ada6 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 5ff4f16e62f..3ec77717007 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 7f33fe280b8..d75a8ac68cb 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 9d86c868953..a71acd2a79f 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 f1406769371..38865003bb3 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 45a57a2f438..01046b00337 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 a961bad927c..190bd4b919c 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 eadf7b18e0a..218c0add8be 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 93ab189dee6..cab778e025b 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 795418f939b..25590661b77 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 68be8440953..9b2343c936c 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 417376b89db..12f8e918b3f 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 fa561de6a38..80374f339c5 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)); diff --git a/tools/gccas/gccas.cpp b/tools/gccas/gccas.cpp index 7e2b6f3e46c..24a5e87b1ba 100644 --- a/tools/gccas/gccas.cpp +++ b/tools/gccas/gccas.cpp @@ -11,8 +11,8 @@ #include "llvm/Assembly/Parser.h" #include "llvm/Transforms/CleanupGCCOutput.h" #include "llvm/Transforms/LevelChange.h" -#include "llvm/Optimizations/DCE.h" #include "llvm/Transforms/ConstantMerge.h" +#include "llvm/Transforms/Scalar/DCE.h" #include "llvm/Transforms/Scalar/IndVarSimplify.h" #include "llvm/Transforms/Scalar/InstructionCombining.h" #include "llvm/Bytecode/Writer.h" @@ -64,13 +64,13 @@ int main(int argc, char **argv) { // a little bit. Do this now. // PassManager Passes; - Passes.add(new opt::DeadCodeElimination()); // Remove Dead code/vars + Passes.add(new DeadCodeElimination()); // Remove Dead code/vars Passes.add(new CleanupGCCOutput()); // Fix gccisms Passes.add(new InductionVariableSimplify()); // Simplify indvars Passes.add(new RaisePointerReferences()); // Eliminate casts Passes.add(new ConstantMerge()); // Merge dup global consts Passes.add(new InstructionCombining()); // Combine silly seq's - Passes.add(new opt::DeadCodeElimination()); // Remove Dead code/vars + Passes.add(new DeadCodeElimination()); // Remove Dead code/vars // Run our queue of passes all at once now, efficiently. This form of // runAllPasses frees the Pass objects after runAllPasses completes. diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index bbf1489ca62..36de3bfbf73 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -9,20 +9,26 @@ #include "llvm/Module.h" #include "llvm/Bytecode/Reader.h" #include "llvm/Bytecode/Writer.h" -#include "llvm/Optimizations/AllOpts.h" -#include "llvm/Transforms/Instrumentation/TraceValues.h" #include "llvm/Assembly/PrintModulePass.h" #include "llvm/Transforms/ConstantMerge.h" #include "llvm/Transforms/CleanupGCCOutput.h" #include "llvm/Transforms/LevelChange.h" +#include "llvm/Transforms/MethodInlining.h" +#include "llvm/Transforms/SymbolStripping.h" #include "llvm/Transforms/IPO/SimpleStructMutation.h" #include "llvm/Transforms/IPO/GlobalDCE.h" +#include "llvm/Transforms/Scalar/DCE.h" +#include "llvm/Transforms/Scalar/ConstantProp.h" +#include "llvm/Transforms/Scalar/InductionVars.h" #include "llvm/Transforms/Scalar/IndVarSimplify.h" #include "llvm/Transforms/Scalar/InstructionCombining.h" +#include "llvm/Transforms/Instrumentation/TraceValues.h" #include "Support/CommandLine.h" #include #include + + enum Opts { // Basic optimizations dce, constprop, inlining, constmerge, strip, mstrip, @@ -41,16 +47,16 @@ struct { enum Opts OptID; Pass *ThePass; } OptTable[] = { - { dce , new opt::DeadCodeElimination() }, - { constprop , new opt::ConstantPropogation() }, - { inlining , new opt::MethodInlining() }, + { dce , new DeadCodeElimination() }, + { constprop , new ConstantPropogation() }, + { inlining , new MethodInlining() }, { constmerge , new ConstantMerge() }, - { strip , new opt::SymbolStripping() }, - { mstrip , new opt::FullSymbolStripping() }, + { strip , new SymbolStripping() }, + { mstrip , new FullSymbolStripping() }, { indvars , new InductionVariableSimplify() }, { instcombine, new InstructionCombining() }, - { sccp , new opt::SCCPPass() }, - { adce , new opt::AgressiveDCE() }, + { sccp , new SCCPPass() }, + { adce , new AgressiveDCE() }, { raise , new RaisePointerReferences() }, { trace , new InsertTraceCode(true, true) }, { tracem , new InsertTraceCode(false, true) },