From bd0ef77cde9c9e82f2b4ad33e4982c46274d6540 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 26 Feb 2002 21:46:54 +0000 Subject: [PATCH] Change over to use new style pass mechanism, now passes only expose small creation functions in their public header file, unless they can help it. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1816 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Transforms/ChangeAllocations.h | 47 +------------ include/llvm/Transforms/FunctionInlining.h | 17 ++--- include/llvm/Transforms/HoistPHIConstants.h | 11 +--- include/llvm/Transforms/IPO.h | 32 +-------- include/llvm/Transforms/IPO/ConstantMerge.h | 42 +----------- include/llvm/Transforms/IPO/GlobalDCE.h | 22 +------ .../Transforms/IPO/SimpleStructMutation.h | 28 +------- .../Transforms/Instrumentation/TraceValues.h | 33 +--------- .../llvm/Transforms/RaisePointerReferences.h | 19 +----- include/llvm/Transforms/Scalar/ConstantProp.h | 33 +++------- include/llvm/Transforms/Scalar/DCE.h | 54 ++++----------- .../llvm/Transforms/Scalar/IndVarSimplify.h | 15 +---- .../Transforms/Scalar/InstructionCombining.h | 11 +--- .../llvm/Transforms/Scalar/SymbolStripping.h | 33 ++-------- .../Transforms/Utils/UnifyFunctionExitNodes.h | 4 ++ lib/Transforms/HoistPHIConstants.cpp | 17 +++-- lib/Transforms/IPO/ConstantMerge.cpp | 61 ++++++++++------- lib/Transforms/IPO/DeadTypeElimination.cpp | 44 ++++++++++--- lib/Transforms/IPO/GlobalDCE.cpp | 36 ++++++---- lib/Transforms/IPO/InlineSimple.cpp | 16 ++++- lib/Transforms/IPO/SimpleStructMutation.cpp | 47 ++++++++++--- .../Instrumentation/TraceValues.cpp | 43 ++++++++++++ lib/Transforms/LevelRaise.cpp | 20 ++++-- lib/Transforms/Scalar/ADCE.cpp | 33 +++++----- lib/Transforms/Scalar/ConstantProp.cpp | 28 ++++---- lib/Transforms/Scalar/DCE.cpp | 58 +++++++++++----- lib/Transforms/Scalar/IndVarSimplify.cpp | 25 +++++-- .../Scalar/InstructionCombining.cpp | 39 +++++++++-- lib/Transforms/Scalar/SCCP.cpp | 20 ++++-- lib/Transforms/Scalar/SymbolStripping.cpp | 27 +++++++- lib/Transforms/Utils/LowerAllocations.cpp | 57 ++++++++++++++++ tools/opt/opt.cpp | 66 +++++++------------ 32 files changed, 527 insertions(+), 511 deletions(-) diff --git a/include/llvm/Transforms/ChangeAllocations.h b/include/llvm/Transforms/ChangeAllocations.h index f0a06859e90..1b837419bd5 100644 --- a/include/llvm/Transforms/ChangeAllocations.h +++ b/include/llvm/Transforms/ChangeAllocations.h @@ -10,51 +10,10 @@ #ifndef LLVM_TRANSFORMS_CHANGEALLOCATIONS_H #define LLVM_TRANSFORMS_CHANGEALLOCATIONS_H -#include "llvm/Pass.h" +class Pass; class TargetData; -// LowerAllocations - Turn malloc and free instructions into %malloc and %free -// calls. -// -class LowerAllocations : public BasicBlockPass { - Method *MallocMeth; // Methods in the module we are processing - Method *FreeMeth; // Initialized by doInitialization - - const TargetData &DataLayout; -public: - inline LowerAllocations(const TargetData &TD) : DataLayout(TD) { - MallocMeth = FreeMeth = 0; - } - - // doPassInitialization - For the lower allocations pass, this ensures that a - // module contains a declaration for a malloc and a free function. - // - bool doInitialization(Module *M); - - // runOnBasicBlock - This method does the actual work of converting - // instructions over, assuming that the pass has already been initialized. - // - bool runOnBasicBlock(BasicBlock *BB); -}; - -// RaiseAllocations - Turn %malloc and %free calls into the appropriate -// instruction. -// -class RaiseAllocations : public BasicBlockPass { - Method *MallocMeth; // Methods in the module we are processing - Method *FreeMeth; // Initialized by doPassInitializationVirt -public: - inline RaiseAllocations() : MallocMeth(0), FreeMeth(0) {} - - // doPassInitialization - For the raise allocations pass, this finds a - // declaration for malloc and free if they exist. - // - bool doInitialization(Module *M); - - // runOnBasicBlock - This method does the actual work of converting - // instructions over, assuming that the pass has already been initialized. - // - bool runOnBasicBlock(BasicBlock *BB); -}; +Pass *createLowerAllocationsPass(const TargetData &TD); +Pass *createRaiseAllocationsPass(); #endif diff --git a/include/llvm/Transforms/FunctionInlining.h b/include/llvm/Transforms/FunctionInlining.h index 252489749e9..e321df52f79 100644 --- a/include/llvm/Transforms/FunctionInlining.h +++ b/include/llvm/Transforms/FunctionInlining.h @@ -4,23 +4,14 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_OPT_METHOD_INLINING_H -#define LLVM_OPT_METHOD_INLINING_H +#ifndef LLVM_TRANSFORMS_METHOD_INLINING_H +#define LLVM_TRANSFORMS_METHOD_INLINING_H -#include "llvm/Pass.h" #include "llvm/BasicBlock.h" class CallInst; +class Pass; -struct MethodInlining : public MethodPass { - // DoMethodInlining - Use a heuristic based approach to inline methods that - // seem to look good. - // - static bool doMethodInlining(Method *M); - - virtual bool runOnMethod(Method *M) { - return doMethodInlining(M); - } -}; +Pass *createMethodInliningPass(); // InlineMethod - This function forcibly inlines the called method into the // basic block of the caller. This returns true if it is not possible to inline diff --git a/include/llvm/Transforms/HoistPHIConstants.h b/include/llvm/Transforms/HoistPHIConstants.h index 27bf7ab0219..3a1bab1bf14 100644 --- a/include/llvm/Transforms/HoistPHIConstants.h +++ b/include/llvm/Transforms/HoistPHIConstants.h @@ -9,14 +9,7 @@ #ifndef LLVM_TRANSFORMS_HOISTPHICONSTANTS_H #define LLVM_TRANSFORMS_HOISTPHICONSTANTS_H -#include "llvm/Pass.h" - -struct HoistPHIConstants : public MethodPass { - // doHoistPHIConstants - Hoist constants out of PHI instructions - // - static bool doHoistPHIConstants(Method *M); - - virtual bool runOnMethod(Method *M) { return doHoistPHIConstants(M); } -}; +class Pass; +Pass *createHoistPHIConstantsPass(); #endif diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h index 313aea2090e..3cc4e76aae2 100644 --- a/include/llvm/Transforms/IPO.h +++ b/include/llvm/Transforms/IPO.h @@ -6,35 +6,7 @@ #ifndef LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H #define LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H -#include "llvm/Pass.h" - -struct CleanupGCCOutput : public MethodPass { - // PatchUpMethodReferences - This is a part of the functionality exported by - // the CleanupGCCOutput pass. This causes functions with different signatures - // to be linked together if they have the same name. - // - static bool PatchUpMethodReferences(Module *M); - - // doPassInitialization - For this pass, it removes global symbol table - // entries for primitive types. These are never used for linking in GCC and - // they make the output uglier to look at, so we nuke them. - // - // Also, initialize instance variables. - // - bool doInitialization(Module *M); - - // doPerMethodWork - This method simplifies the specified method hopefully. - // - bool runOnMethod(Method *M); - - // doPassFinalization - Strip out type names that are unused by the program - bool doFinalization(Module *M); - - // getAnalysisUsageInfo - This function needs FindUsedTypes to do its job... - // - virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided); -}; +class Pass; +Pass *createCleanupGCCOutputPass(); #endif diff --git a/include/llvm/Transforms/IPO/ConstantMerge.h b/include/llvm/Transforms/IPO/ConstantMerge.h index efc91f400b3..b25fb66670a 100644 --- a/include/llvm/Transforms/IPO/ConstantMerge.h +++ b/include/llvm/Transforms/IPO/ConstantMerge.h @@ -17,44 +17,8 @@ #ifndef LLVM_TRANSFORMS_CONSTANTMERGE_H #define LLVM_TRANSFORMS_CONSTANTMERGE_H -#include "llvm/Pass.h" -class Constant; -class GlobalVariable; - -// FIXME: ConstantMerge should not be a methodPass!!! -class ConstantMerge : public MethodPass { -protected: - std::map Constants; - unsigned LastConstantSeen; -public: - inline ConstantMerge() : LastConstantSeen(0) {} - - // mergeDuplicateConstants - Static accessor for clients that don't want to - // deal with passes. - // - static bool mergeDuplicateConstants(Module *M); - - // doInitialization - For this pass, process all of the globals in the - // module, eliminating duplicate constants. - // - bool doInitialization(Module *M); - - bool runOnMethod(Method*) { return false; } - - // doFinalization - Clean up internal state for this module - // - bool doFinalization(Module *M) { - LastConstantSeen = 0; - Constants.clear(); - return false; - } -}; - -struct DynamicConstantMerge : public ConstantMerge { - // doPerMethodWork - Check to see if any globals have been added to the - // global list for the module. If so, eliminate them. - // - bool runOnMethod(Method *M); -}; +class Pass; +Pass *createConstantMergePass(); +Pass *createDynamicConstantMergePass(); #endif diff --git a/include/llvm/Transforms/IPO/GlobalDCE.h b/include/llvm/Transforms/IPO/GlobalDCE.h index 497416cbce3..8956fc37e6c 100644 --- a/include/llvm/Transforms/IPO/GlobalDCE.h +++ b/include/llvm/Transforms/IPO/GlobalDCE.h @@ -7,25 +7,7 @@ #ifndef LLVM_TRANSFORM_IPO_GLOBALDCE_H #define LLVM_TRANSFORM_IPO_GLOBALDCE_H -#include "llvm/Pass.h" - -namespace cfg { class CallGraph; } -class Module; - -struct GlobalDCE : public Pass { - - // run - Do the GlobalDCE pass on the specified module, optionally updating - // the specified callgraph to reflect the changes. - // - bool run(Module *M); - - // getAnalysisUsageInfo - This function works on the call graph of a module. - // It is capable of updating the call graph to reflect the new state of the - // module. - // - virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided); -}; +class Pass; +Pass *createGlobalDCEPass(); #endif diff --git a/include/llvm/Transforms/IPO/SimpleStructMutation.h b/include/llvm/Transforms/IPO/SimpleStructMutation.h index f159c4de022..ccfcea771ab 100644 --- a/include/llvm/Transforms/IPO/SimpleStructMutation.h +++ b/include/llvm/Transforms/IPO/SimpleStructMutation.h @@ -8,30 +8,8 @@ #ifndef LLVM_TRANSFORMS_SIMPLESTRUCTMUTATION_H #define LLVM_TRANSFORMS_SIMPLESTRUCTMUTATION_H -#include "llvm/Transforms/IPO/MutateStructTypes.h" - -class SimpleStructMutation : public MutateStructTypes { -public: - enum Transform { SwapElements, SortElements } CurrentXForm; - - SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {} - - virtual bool run(Module *M) { - setTransforms(getTransforms(M, CurrentXForm)); - bool Changed = MutateStructTypes::run(M); - clearTransforms(); - return Changed; - } - - // getAnalysisUsageInfo - This function needs the results of the - // FindUsedTypes and FindUnsafePointerTypes analysis passes... - // - virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided); - -private: - TransformsType getTransforms(Module *M, enum Transform); -}; +class Pass; +Pass *createSwapElementsPass(); +Pass *createSortElementsPass(); #endif diff --git a/include/llvm/Transforms/Instrumentation/TraceValues.h b/include/llvm/Transforms/Instrumentation/TraceValues.h index 996db1747ef..0519e1d67cb 100644 --- a/include/llvm/Transforms/Instrumentation/TraceValues.h +++ b/include/llvm/Transforms/Instrumentation/TraceValues.h @@ -8,35 +8,8 @@ #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_TRACEVALUES_H #define LLVM_TRANSFORMS_INSTRUMENTATION_TRACEVALUES_H -#include "llvm/Pass.h" -class Method; - -class InsertTraceCode : public MethodPass { - bool TraceBasicBlockExits, TraceMethodExits; - Method *PrintfMeth; -public: - InsertTraceCode(bool traceBasicBlockExits, bool traceMethodExits) - : TraceBasicBlockExits(traceBasicBlockExits), - TraceMethodExits(traceMethodExits) {} - - // Add a prototype for printf if it is not already in the program. - // - bool doInitialization(Module *M); - - //-------------------------------------------------------------------------- - // Function InsertCodeToTraceValues - // - // Inserts tracing code for all live values at basic block and/or method exits - // as specified by `traceBasicBlockExits' and `traceMethodExits'. - // - static bool doit(Method *M, bool traceBasicBlockExits, - bool traceMethodExits, Method *Printf); - - // runOnMethod - This method does the work. Always successful. - // - bool runOnMethod(Method *M) { - return doit(M, TraceBasicBlockExits, TraceMethodExits, PrintfMeth); - } -}; +class Pass; +Pass *createTraceValuesPassForMethod(); // Just trace methods +Pass *createTraceValuesPassForBasicBlocks(); // Trace BB's and methods #endif diff --git a/include/llvm/Transforms/RaisePointerReferences.h b/include/llvm/Transforms/RaisePointerReferences.h index b652f33712f..ec2ce319a31 100644 --- a/include/llvm/Transforms/RaisePointerReferences.h +++ b/include/llvm/Transforms/RaisePointerReferences.h @@ -9,27 +9,12 @@ #ifndef LLVM_TRANSFORMS_LEVELCHANGE_H #define LLVM_TRANSFORMS_LEVELCHANGE_H -#include "llvm/Pass.h" +class Pass; // RaisePointerReferences - Try to eliminate as many pointer arithmetic // expressions as possible, by converting expressions to use getelementptr and // friends. // -struct RaisePointerReferences : public MethodPass { - static bool doit(Method *M); - - virtual bool runOnMethod(Method *M) { return doit(M); } -}; - - -// EliminateAuxillaryInductionVariables - Eliminate all aux indvars. This -// converts all induction variables to reference a cannonical induction -// variable (which starts at 0 and counts by 1). -// -struct EliminateAuxillaryInductionVariables : public MethodPass { - static bool doit(Method *M) { return false; } // TODO! - - virtual bool runOnMethod(Method *M) { return doit(M); } -}; +Pass *createRaisePointerReferencesPass(); #endif diff --git a/include/llvm/Transforms/Scalar/ConstantProp.h b/include/llvm/Transforms/Scalar/ConstantProp.h index c4d973516c4..3a8fa5b6d9a 100644 --- a/include/llvm/Transforms/Scalar/ConstantProp.h +++ b/include/llvm/Transforms/Scalar/ConstantProp.h @@ -7,26 +7,19 @@ #ifndef LLVM_TRANSFORMS_SCALAR_CONSTANT_PROPOGATION_H #define LLVM_TRANSFORMS_SCALAR_CONSTANT_PROPOGATION_H -#include "llvm/Pass.h" #include "llvm/BasicBlock.h" class TerminatorInst; +class Pass; -struct ConstantPropogation : public MethodPass { - // doConstantPropogation - Do trivial constant propogation and expression - // folding - static bool doConstantPropogation(Method *M); - - // doConstantPropogation - Constant prop a specific instruction. Returns true - // and potentially moves the iterator if constant propogation was performed. - // - static bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &I); - - inline bool runOnMethod(Method *M) { - return doConstantPropogation(M); - } -}; - +//===----------------------------------------------------------------------===// +// Normal Constant Propogation Pass +// +Pass *createConstantPropogationPass(); +// doConstantPropogation - Constant prop a specific instruction. Returns true +// and potentially moves the iterator if constant propogation was performed. +// +bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &I); // ConstantFoldTerminator - If a terminator instruction is predicated on a // constant value, convert it into an unconditional branch to the constant @@ -38,12 +31,6 @@ bool ConstantFoldTerminator(TerminatorInst *T); //===----------------------------------------------------------------------===// // Sparse Conditional Constant Propogation Pass // -struct SCCPPass : public MethodPass { - static bool doSCCP(Method *M); - - inline bool runOnMethod(Method *M) { - return doSCCP(M); - } -}; +Pass *createSCCPPass(); #endif diff --git a/include/llvm/Transforms/Scalar/DCE.h b/include/llvm/Transforms/Scalar/DCE.h index 3246ed85e56..a8dcb591467 100644 --- a/include/llvm/Transforms/Scalar/DCE.h +++ b/include/llvm/Transforms/Scalar/DCE.h @@ -5,21 +5,19 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_OPT_DCE_H -#define LLVM_OPT_DCE_H +#ifndef LLVM_TRANSFORMS_SCALAR_DCE_H +#define LLVM_TRANSFORMS_SCALAR_DCE_H -#include "llvm/Pass.h" #include "llvm/Method.h" #include "llvm/BasicBlock.h" +class Pass; //===----------------------------------------------------------------------===// // DeadInstElimination - This pass quickly removes trivially dead instructions // without modifying the CFG of the function. It is a BasicBlockPass, so it // runs efficiently when queued next to other BasicBlockPass's. // -struct DeadInstElimination : public BasicBlockPass { - virtual bool runOnBasicBlock(BasicBlock *BB); -}; +Pass *createDeadInstEliminationPass(); //===----------------------------------------------------------------------===// @@ -32,34 +30,16 @@ struct DeadInstElimination : public BasicBlockPass { // otherwise simplifies control flow. This should be factored out of this pass // eventually into it's own pass. // -struct DeadCodeElimination : public MethodPass { - // External Interface: - // - static bool doDCE(Method *M); - // 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. - // - static bool dceInstruction(BasicBlock::InstListType &BBIL, - BasicBlock::iterator &BBI); +Pass *createDeadCodeEliminationPass(); - // Remove unused global values - This removes unused global values of no - // possible value. This currently includes unused method prototypes and - // unitialized global variables. - // - static bool RemoveUnusedGlobalValues(Module *M); - - // Pass Interface... - virtual bool doInitialization(Module *M) { - return RemoveUnusedGlobalValues(M); - } - virtual bool runOnMethod(Method *M) { return doDCE(M); } - virtual bool doFinalization(Module *M) { - return RemoveUnusedGlobalValues(M); - } -}; +// 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); @@ -68,15 +48,7 @@ struct DeadCodeElimination : public MethodPass { // algorithm assumes instructions are dead until proven otherwise, which makes // it more successful are removing non-obviously dead instructions. // -struct AgressiveDCE : public MethodPass { - virtual bool runOnMethod(Method *M); - - // getAnalysisUsageInfo - We require post dominance frontiers (aka Control - // Dependence Graph) - virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided); -}; +Pass *createAgressiveDCEPass(); // SimplifyCFG - This function is used to do simplification of a CFG. For diff --git a/include/llvm/Transforms/Scalar/IndVarSimplify.h b/include/llvm/Transforms/Scalar/IndVarSimplify.h index 902483eb8cb..4fda9e77c28 100644 --- a/include/llvm/Transforms/Scalar/IndVarSimplify.h +++ b/include/llvm/Transforms/Scalar/IndVarSimplify.h @@ -8,18 +8,7 @@ #ifndef LLVM_TRANSFORMS_SCALAR_INDVARSIMPLIFY_H #define LLVM_TRANSFORMS_SCALAR_INDVARSIMPLIFY_H -#include "llvm/Pass.h" - -namespace cfg { class LoopInfo; } - -struct InductionVariableSimplify : public MethodPass { - static bool doit(Method *M, cfg::LoopInfo &Loops); - - virtual bool runOnMethod(Method *M); - - virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided); -}; +class Pass; +Pass *createIndVarSimplifyPass(); #endif diff --git a/include/llvm/Transforms/Scalar/InstructionCombining.h b/include/llvm/Transforms/Scalar/InstructionCombining.h index 0c395720e66..37b49858ba7 100644 --- a/include/llvm/Transforms/Scalar/InstructionCombining.h +++ b/include/llvm/Transforms/Scalar/InstructionCombining.h @@ -15,14 +15,7 @@ #ifndef LLVM_TRANSFORMS_SCALAR_INSTRUCTIONCOMBINING_H #define LLVM_TRANSFORMS_SCALAR_INSTRUCTIONCOMBINING_H -#include "llvm/Pass.h" -class Instruction; - -struct InstructionCombining : public MethodPass { - static bool doit(Method *M); - static bool CombineInstruction(Instruction *I); - - virtual bool runOnMethod(Method *M) { return doit(M); } -}; +class Pass; +Pass *createInstructionCombiningPass(); #endif diff --git a/include/llvm/Transforms/Scalar/SymbolStripping.h b/include/llvm/Transforms/Scalar/SymbolStripping.h index 156e21171f2..f9b7c605534 100644 --- a/include/llvm/Transforms/Scalar/SymbolStripping.h +++ b/include/llvm/Transforms/Scalar/SymbolStripping.h @@ -5,35 +5,12 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_OPT_SYMBOL_STRIPPING_H -#define LLVM_OPT_SYMBOL_STRIPPING_H +#ifndef LLVM_TRANSFORMS_SYMBOL_STRIPPING_H +#define LLVM_TRANSFORMS_SYMBOL_STRIPPING_H -#include "llvm/Pass.h" +class Pass; -struct SymbolStripping : public MethodPass { - // doSymbolStripping - Remove all symbolic information from a method - // - static bool doSymbolStripping(Method *M); - - virtual bool runOnMethod(Method *M) { - return doSymbolStripping(M); - } -}; - -struct FullSymbolStripping : public MethodPass { - - // doStripGlobalSymbols - Remove all symbolic information from all methods - // in a module, and all module level symbols. (method names, etc...) - // - static bool doStripGlobalSymbols(Module *M); - - virtual bool doInitialization(Module *M) { - return doStripGlobalSymbols(M); - } - - virtual bool runOnMethod(Method *M) { - return SymbolStripping::doSymbolStripping(M); - } -}; +Pass *createSymbolStrippingPass(); +Pass *createFullSymbolStrippingPass(); #endif diff --git a/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h b/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h index e923b923049..4c87b096f89 100644 --- a/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h +++ b/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h @@ -40,4 +40,8 @@ public: } }; +static inline Pass *createUnifyMethodExitNodesPass() { + return new UnifyMethodExitNodes(); +} + #endif diff --git a/lib/Transforms/HoistPHIConstants.cpp b/lib/Transforms/HoistPHIConstants.cpp index 43ed725d945..f20de1cfc21 100644 --- a/lib/Transforms/HoistPHIConstants.cpp +++ b/lib/Transforms/HoistPHIConstants.cpp @@ -11,6 +11,7 @@ #include "llvm/iOther.h" #include "llvm/BasicBlock.h" #include "llvm/Method.h" +#include "llvm/Pass.h" #include #include @@ -19,12 +20,6 @@ typedef std::map CachedCopyMap; static Value *NormalizePhiOperand(PHINode *PN, Value *CPV, BasicBlock *Pred, CachedCopyMap &CopyCache) { - - /* NOTE: CahedCopyMap was disabled to insert phi elimination code - for all phi args -- Ruchira - */ - - // Check if we've already inserted a copy for this constant in Pred // Note that `copyCache[Pred]' will create an empty vector the first time // @@ -47,7 +42,7 @@ static Value *NormalizePhiOperand(PHINode *PN, Value *CPV, // Entry point for normalizing constant args in PHIs //--------------------------------------------------------------------------- -bool HoistPHIConstants::doHoistPHIConstants(Method *M) { +static bool doHoistPHIConstants(Method *M) { CachedCopyMap Cache; bool Changed = false; @@ -77,3 +72,11 @@ bool HoistPHIConstants::doHoistPHIConstants(Method *M) { return Changed; } + +namespace { + struct HoistPHIConstants : public MethodPass { + virtual bool runOnMethod(Method *M) { return doHoistPHIConstants(M); } + }; +} + +Pass *createHoistPHIConstantsPass() { return new HoistPHIConstants(); } diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp index 0951c731e1c..d78d185e8af 100644 --- a/lib/Transforms/IPO/ConstantMerge.cpp +++ b/lib/Transforms/IPO/ConstantMerge.cpp @@ -18,6 +18,7 @@ #include "llvm/GlobalVariable.h" #include "llvm/Module.h" #include "llvm/Method.h" +#include "llvm/Pass.h" // mergeDuplicateConstants - Workhorse for the pass. This eliminates duplicate // constants, starting at global ConstantNo, and adds vars to the map if they @@ -56,27 +57,43 @@ bool mergeDuplicateConstants(Module *M, unsigned &ConstantNo, return MadeChanges; } - -// mergeDuplicateConstants - Static accessor for clients that don't want to -// deal with passes. -// -bool ConstantMerge::mergeDuplicateConstants(Module *M) { - std::map Constants; - unsigned LastConstantSeen = 0; - return ::mergeDuplicateConstants(M, LastConstantSeen, Constants); -} - - -// doInitialization - For this pass, process all of the globals in the -// module, eliminating duplicate constants. -// -bool ConstantMerge::doInitialization(Module *M) { - return ::mergeDuplicateConstants(M, LastConstantSeen, Constants); +namespace { + // FIXME: ConstantMerge should not be a methodPass!!! + class ConstantMerge : public MethodPass { + protected: + std::map Constants; + unsigned LastConstantSeen; + public: + inline ConstantMerge() : LastConstantSeen(0) {} + + // doInitialization - For this pass, process all of the globals in the + // module, eliminating duplicate constants. + // + bool doInitialization(Module *M) { + return ::mergeDuplicateConstants(M, LastConstantSeen, Constants); + } + + bool runOnMethod(Method*) { return false; } + + // doFinalization - Clean up internal state for this module + // + bool doFinalization(Module *M) { + LastConstantSeen = 0; + Constants.clear(); + return false; + } + }; + + struct DynamicConstantMerge : public ConstantMerge { + // doPerMethodWork - Check to see if any globals have been added to the + // global list for the module. If so, eliminate them. + // + bool runOnMethod(Method *M) { + return ::mergeDuplicateConstants(M->getParent(), LastConstantSeen, + Constants); + } + }; } -// doPerMethodWork - Check to see if any globals have been added to the -// global list for the module. If so, eliminate them. -// -bool DynamicConstantMerge::runOnMethod(Method *M) { - return ::mergeDuplicateConstants(M->getParent(), LastConstantSeen, Constants); -} +Pass *createConstantMergePass() { return new ConstantMerge(); } +Pass *createDynamicConstantMergePass() { return new DynamicConstantMerge(); } diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index 09d8db4eb85..801cdffb7e7 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -23,6 +23,7 @@ #include "llvm/iTerminators.h" #include "llvm/iOther.h" #include "llvm/Support/CFG.h" +#include "llvm/Pass.h" #include #include using std::vector; @@ -31,6 +32,36 @@ using std::cerr; static const Type *PtrSByte = 0; // 'sbyte*' type +namespace { + struct CleanupGCCOutput : public MethodPass { + // doPassInitialization - For this pass, it removes global symbol table + // entries for primitive types. These are never used for linking in GCC and + // they make the output uglier to look at, so we nuke them. + // + // Also, initialize instance variables. + // + bool doInitialization(Module *M); + + // doPerMethodWork - This method simplifies the specified method hopefully. + // + bool runOnMethod(Method *M); + + // doPassFinalization - Strip out type names that are unused by the program + bool doFinalization(Module *M); + + // getAnalysisUsageInfo - This function needs FindUsedTypes to do its job... + // + virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, + Pass::AnalysisSet &Destroyed, + Pass::AnalysisSet &Provided) { + // FIXME: Invalidates the CFG + Required.push_back(FindUsedTypes::ID); + } + }; +} + + + // ConvertCallTo - Convert a call to a varargs function with no arg types // specified to a concrete nonvarargs method. // @@ -79,7 +110,7 @@ static void ConvertCallTo(CallInst *CI, Method *Dest) { // because of the way things are declared in C. If this is the case, patch // things up. // -bool CleanupGCCOutput::PatchUpMethodReferences(Module *M) { +static bool PatchUpMethodReferences(Module *M) { SymbolTable *ST = M->getSymbolTable(); if (!ST) return false; @@ -545,12 +576,7 @@ bool CleanupGCCOutput::doFinalization(Module *M) { return Changed; } -// getAnalysisUsageInfo - This function needs the results of the -// FindUsedTypes and FindUnsafePointerTypes analysis passes... -// -void CleanupGCCOutput::getAnalysisUsageInfo(Pass::AnalysisSet &Required, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided) { - // FIXME: Invalidates the CFG - Required.push_back(FindUsedTypes::ID); +Pass *createCleanupGCCOutputPass() { + return new CleanupGCCOutput(); } + diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp index 1b64a0b369b..454f6014e6d 100644 --- a/lib/Transforms/IPO/GlobalDCE.cpp +++ b/lib/Transforms/IPO/GlobalDCE.cpp @@ -8,6 +8,7 @@ #include "llvm/Analysis/CallGraph.h" #include "llvm/Module.h" #include "llvm/Method.h" +#include "llvm/Pass.h" #include "Support/DepthFirstIterator.h" #include @@ -45,18 +46,27 @@ static bool RemoveUnreachableMethods(Module *M, cfg::CallGraph &CallGraph) { return true; } -bool GlobalDCE::run(Module *M) { - return RemoveUnreachableMethods(M, getAnalysis()); -} +namespace { + struct GlobalDCE : public Pass { + // run - Do the GlobalDCE pass on the specified module, optionally updating + // the specified callgraph to reflect the changes. + // + bool run(Module *M) { + return RemoveUnreachableMethods(M, getAnalysis()); + } -// getAnalysisUsageInfo - This function works on the call graph of a module. -// It is capable of updating the call graph to reflect the new state of the -// module. -// -void GlobalDCE::getAnalysisUsageInfo(Pass::AnalysisSet &Required, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided) { - Required.push_back(cfg::CallGraph::ID); - // FIXME: This should update the callgraph, not destroy it! - Destroyed.push_back(cfg::CallGraph::ID); + // getAnalysisUsageInfo - This function works on the call graph of a module. + // It is capable of updating the call graph to reflect the new state of the + // module. + // + virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, + Pass::AnalysisSet &Destroyed, + Pass::AnalysisSet &Provided) { + Required.push_back(cfg::CallGraph::ID); + // FIXME: This should update the callgraph, not destroy it! + Destroyed.push_back(cfg::CallGraph::ID); + } + }; } + +Pass *createGlobalDCEPass() { return new GlobalDCE(); } diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index d4c23a92089..9ca23f74484 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -21,6 +21,7 @@ #include "llvm/Transforms/MethodInlining.h" #include "llvm/Module.h" #include "llvm/Method.h" +#include "llvm/Pass.h" #include "llvm/iTerminators.h" #include "llvm/iPHINode.h" #include "llvm/iOther.h" @@ -249,7 +250,10 @@ static inline bool DoMethodInlining(BasicBlock *BB) { return false; } -bool MethodInlining::doMethodInlining(Method *M) { +// doMethodInlining - Use a heuristic based approach to inline methods that +// seem to look good. +// +static bool doMethodInlining(Method *M) { bool Changed = false; // Loop through now and inline instructions a basic block at a time... @@ -264,3 +268,13 @@ bool MethodInlining::doMethodInlining(Method *M) { return Changed; } + +namespace { + struct MethodInlining : public MethodPass { + virtual bool runOnMethod(Method *M) { + return doMethodInlining(M); + } + }; +} + +Pass *createMethodInliningPass() { return new MethodInlining(); } diff --git a/lib/Transforms/IPO/SimpleStructMutation.cpp b/lib/Transforms/IPO/SimpleStructMutation.cpp index 8583e3e850d..168f8397366 100644 --- a/lib/Transforms/IPO/SimpleStructMutation.cpp +++ b/lib/Transforms/IPO/SimpleStructMutation.cpp @@ -19,6 +19,37 @@ using std::pair; #include "llvm/Assembly/Writer.h" +namespace { + class SimpleStructMutation : public MutateStructTypes { + public: + enum Transform { SwapElements, SortElements } CurrentXForm; + + SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {} + + virtual bool run(Module *M) { + setTransforms(getTransforms(M, CurrentXForm)); + bool Changed = MutateStructTypes::run(M); + clearTransforms(); + return Changed; + } + + // getAnalysisUsageInfo - This function needs the results of the + // FindUsedTypes and FindUnsafePointerTypes analysis passes... + // + virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, + Pass::AnalysisSet &Destroyed, + Pass::AnalysisSet &Provided) { + Required.push_back(FindUsedTypes::ID); + Required.push_back(FindUnsafePointerTypes::ID); + MutateStructTypes::getAnalysisUsageInfo(Required, Destroyed, Provided); + } + + private: + TransformsType getTransforms(Module *M, enum Transform); + }; +} // end anonymous namespace + + // PruneTypes - Given a type Ty, make sure that neither it, or one of its // subtypes, occur in TypesToModify. @@ -87,6 +118,7 @@ static inline void GetTransformation(const StructType *ST, } } + SimpleStructMutation::TransformsType SimpleStructMutation::getTransforms(Module *M, enum Transform XForm) { // We need to know which types to modify, and which types we CAN'T modify @@ -137,13 +169,10 @@ SimpleStructMutation::TransformsType } -// getAnalysisUsageInfo - This function needs the results of the -// FindUsedTypes and FindUnsafePointerTypes analysis passes... -// -void SimpleStructMutation::getAnalysisUsageInfo(Pass::AnalysisSet &Required, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided){ - Required.push_back(FindUsedTypes::ID); - Required.push_back(FindUnsafePointerTypes::ID); - MutateStructTypes::getAnalysisUsageInfo(Required, Destroyed, Provided); +Pass *createSwapElementsPass() { + return new SimpleStructMutation(SimpleStructMutation::SwapElements); +} +Pass *createSortElementsPass() { + return new SimpleStructMutation(SimpleStructMutation::SortElements); } + diff --git a/lib/Transforms/Instrumentation/TraceValues.cpp b/lib/Transforms/Instrumentation/TraceValues.cpp index aad63c848f2..6e4fedcfa85 100644 --- a/lib/Transforms/Instrumentation/TraceValues.cpp +++ b/lib/Transforms/Instrumentation/TraceValues.cpp @@ -15,12 +15,55 @@ #include "llvm/Method.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" +#include "llvm/Pass.h" #include "llvm/Assembly/Writer.h" #include "Support/StringExtras.h" #include using std::vector; using std::string; +namespace { + class InsertTraceCode : public MethodPass { + bool TraceBasicBlockExits, TraceMethodExits; + Method *PrintfMeth; + public: + InsertTraceCode(bool traceBasicBlockExits, bool traceMethodExits) + : TraceBasicBlockExits(traceBasicBlockExits), + TraceMethodExits(traceMethodExits) {} + + // Add a prototype for printf if it is not already in the program. + // + bool doInitialization(Module *M); + + //-------------------------------------------------------------------------- + // Function InsertCodeToTraceValues + // + // Inserts tracing code for all live values at basic block and/or method + // exits as specified by `traceBasicBlockExits' and `traceMethodExits'. + // + static bool doit(Method *M, bool traceBasicBlockExits, + bool traceMethodExits, Method *Printf); + + // runOnMethod - This method does the work. Always successful. + // + bool runOnMethod(Method *M) { + return doit(M, TraceBasicBlockExits, TraceMethodExits, PrintfMeth); + } + }; +} // end anonymous namespace + + +Pass *createTraceValuesPassForMethod() { // Just trace methods + return new InsertTraceCode(false, true); +} + +Pass *createTraceValuesPassForBasicBlocks() { // Trace BB's and methods + return new InsertTraceCode(true, true); +} + + + + // Add a prototype for printf if it is not already in the program. // bool InsertTraceCode::doInitialization(Module *M) { diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp index ef0a5fd314d..2826e9f216c 100644 --- a/lib/Transforms/LevelRaise.cpp +++ b/lib/Transforms/LevelRaise.cpp @@ -12,6 +12,7 @@ #include "llvm/iOther.h" #include "llvm/iMemory.h" #include "llvm/ConstantVals.h" +#include "llvm/Pass.h" #include "llvm/Transforms/Scalar/DCE.h" #include "llvm/Transforms/Scalar/ConstantHandling.h" #include "llvm/Transforms/Scalar/ConstantProp.h" @@ -413,8 +414,7 @@ static bool DoRaisePass(Method *M) { #if DEBUG_PEEPHOLE_INSTS cerr << "Processing: " << *BI; #endif - if (DeadCodeElimination::dceInstruction(BIL, BI) || - ConstantPropogation::doConstantPropogation(BB, BI)) { + if (dceInstruction(BIL, BI) || doConstantPropogation(BB, BI)) { Changed = true; #ifdef DEBUG_PEEPHOLE_INSTS cerr << "DeadCode Elinated!\n"; @@ -429,12 +429,10 @@ static bool DoRaisePass(Method *M) { } - - // RaisePointerReferences::doit - Raise a method representation to a higher // level. // -bool RaisePointerReferences::doit(Method *M) { +static bool doRPR(Method *M) { #ifdef DEBUG_PEEPHOLE_INSTS cerr << "\n\n\nStarting to work on Method '" << M->getName() << "'\n"; #endif @@ -459,3 +457,15 @@ bool RaisePointerReferences::doit(Method *M) { return Changed; } + +namespace { + struct RaisePointerReferences : public MethodPass { + virtual bool runOnMethod(Method *M) { return doRPR(M); } + }; +} + +Pass *createRaisePointerReferencesPass() { + return new RaisePointerReferences(); +} + + diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp index 91bed41f6c3..14c68f410e1 100644 --- a/lib/Transforms/Scalar/ADCE.cpp +++ b/lib/Transforms/Scalar/ADCE.cpp @@ -288,21 +288,24 @@ BasicBlock *ADCE::fixupCFG(BasicBlock *BB, std::set &VisitedBlocks, } } - - -// doADCE - Execute the Agressive Dead Code Elimination Algorithm -// -bool AgressiveDCE::runOnMethod(Method *M) { - return ADCE(M).doADCE( - getAnalysis(cfg::DominanceFrontier::PostDomID)); +namespace { + struct AgressiveDCE : public MethodPass { + // doADCE - Execute the Agressive Dead Code Elimination Algorithm + // + virtual bool runOnMethod(Method *M) { + return ADCE(M).doADCE( + getAnalysis(cfg::DominanceFrontier::PostDomID)); + } + // getAnalysisUsageInfo - We require post dominance frontiers (aka Control + // Dependence Graph) + virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires, + Pass::AnalysisSet &Destroyed, + Pass::AnalysisSet &Provided) { + Requires.push_back(cfg::DominanceFrontier::PostDomID); + } + }; } - -// getAnalysisUsageInfo - We require post dominance frontiers (aka Control -// Dependence Graph) -// -void AgressiveDCE::getAnalysisUsageInfo(Pass::AnalysisSet &Requires, - Pass::AnalysisSet &Destroyed, - Pass::AnalysisSet &Provided) { - Requires.push_back(cfg::DominanceFrontier::PostDomID); +Pass *createAgressiveDCEPass() { + return new AgressiveDCE(); } diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp index 190bd4b919c..fc4e3bf0e3e 100644 --- a/lib/Transforms/Scalar/ConstantProp.cpp +++ b/lib/Transforms/Scalar/ConstantProp.cpp @@ -29,6 +29,7 @@ #include "llvm/iTerminators.h" #include "llvm/iPHINode.h" #include "llvm/iOther.h" +#include "llvm/Pass.h" #include "llvm/ConstantVals.h" inline static bool @@ -153,8 +154,7 @@ bool ConstantFoldTerminator(TerminatorInst *T) { // ConstantFoldInstruction - If an instruction references constants, try to fold // them together... // -bool ConstantPropogation::doConstantPropogation(BasicBlock *BB, - BasicBlock::iterator &II) { +bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &II) { Instruction *Inst = *II; if (isa(Inst)) { Constant *D1 = dyn_cast(Inst->getOperand(0)); @@ -200,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 (ConstantPropogation::doConstantPropogation(BB, I)) + if (doConstantPropogation(BB, I)) SomethingChanged = true; else ++I; @@ -208,14 +208,20 @@ static bool DoConstPropPass(Method *M) { return SomethingChanged; } +namespace { + struct ConstantPropogation : public MethodPass { + inline bool runOnMethod(Method *M) { + bool Modified = false; -// returns whether or not the underlying method was modified -// -bool ConstantPropogation::doConstantPropogation(Method *M) { - bool Modified = false; - - // Fold constants until we make no progress... - while (DoConstPropPass(M)) Modified = true; + // Fold constants until we make no progress... + while (DoConstPropPass(M)) Modified = true; + + return Modified; + } + }; +} - return Modified; +Pass *createConstantPropogationPass() { + return new ConstantPropogation(); } + diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp index 8f351a1431c..491c957fb2a 100644 --- a/lib/Transforms/Scalar/DCE.cpp +++ b/lib/Transforms/Scalar/DCE.cpp @@ -32,6 +32,7 @@ #include "llvm/iPHINode.h" #include "llvm/Assembly/Writer.h" #include "llvm/Support/CFG.h" +#include "llvm/Pass.h" #include "Support/STLExtras.h" #include @@ -40,8 +41,8 @@ // to point to the instruction that immediately succeeded the original // instruction. // -bool DeadCodeElimination::dceInstruction(BasicBlock::InstListType &BBIL, - BasicBlock::iterator &BBI) { +bool dceInstruction(BasicBlock::InstListType &BBIL, + BasicBlock::iterator &BBI) { // Look for un"used" definitions... if ((*BBI)->use_empty() && !(*BBI)->hasSideEffects() && !isa(*BBI)) { @@ -55,15 +56,21 @@ static inline bool RemoveUnusedDefs(BasicBlock::InstListType &Vals) { bool Changed = false; for (BasicBlock::InstListType::iterator DI = Vals.begin(); DI != Vals.end(); ) - if (DeadCodeElimination::dceInstruction(Vals, DI)) + if (dceInstruction(Vals, DI)) Changed = true; else ++DI; return Changed; } -bool DeadInstElimination::runOnBasicBlock(BasicBlock *BB) { - return RemoveUnusedDefs(BB->getInstList()); +struct DeadInstElimination : public BasicBlockPass { + virtual bool runOnBasicBlock(BasicBlock *BB) { + return RemoveUnusedDefs(BB->getInstList()); + } +}; + +Pass *createDeadInstEliminationPass() { + return new DeadInstElimination(); } // RemoveSingularPHIs - This removes PHI nodes from basic blocks that have only @@ -297,17 +304,11 @@ static bool DoDCEPass(Method *M) { return Changed; } - -// It is possible that we may require multiple passes over the code to fully -// eliminate dead code. Iterate until we are done. +// Remove unused global values - This removes unused global values of no +// possible value. This currently includes unused method prototypes and +// unitialized global variables. // -bool DeadCodeElimination::doDCE(Method *M) { - bool Changed = false; - while (DoDCEPass(M)) Changed = true; - return Changed; -} - -bool DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) { +static bool RemoveUnusedGlobalValues(Module *Mod) { bool Changed = false; for (Module::iterator MI = Mod->begin(); MI != Mod->end(); ) { @@ -338,3 +339,30 @@ bool DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) { return Changed; } + +namespace { + struct DeadCodeElimination : public MethodPass { + + // Pass Interface... + virtual bool doInitialization(Module *M) { + return RemoveUnusedGlobalValues(M); + } + + // It is possible that we may require multiple passes over the code to fully + // eliminate dead code. Iterate until we are done. + // + virtual bool runOnMethod(Method *M) { + bool Changed = false; + while (DoDCEPass(M)) Changed = true; + return Changed; + } + + virtual bool doFinalization(Module *M) { + return RemoveUnusedGlobalValues(M); + } + }; +} + +Pass *createDeadCodeEliminationPass() { + return new DeadCodeElimination(); +} diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index 692fcacb7e3..fcf49e171a6 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -13,6 +13,7 @@ #include "llvm/Type.h" #include "llvm/BasicBlock.h" #include "llvm/ConstantVals.h" +#include "llvm/Pass.h" #include "llvm/Support/CFG.h" #include "Support/STLExtras.h" @@ -186,19 +187,29 @@ static bool TransformLoop(cfg::LoopInfo *Loops, cfg::Loop *Loop) { return Changed; } -bool InductionVariableSimplify::doit(Method *M, cfg::LoopInfo &Loops) { +static bool doit(Method *M, cfg::LoopInfo &Loops) { // Induction Variables live in the header nodes of the loops of the method... return reduce_apply_bool(Loops.getTopLevelLoops().begin(), Loops.getTopLevelLoops().end(), std::bind1st(std::ptr_fun(TransformLoop), &Loops)); } -bool InductionVariableSimplify::runOnMethod(Method *M) { - return doit(M, getAnalysis()); + +namespace { + struct InductionVariableSimplify : public MethodPass { + virtual bool runOnMethod(Method *M) { + return doit(M, getAnalysis()); + } + + virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, + Pass::AnalysisSet &Destroyed, + Pass::AnalysisSet &Provided) { + Required.push_back(cfg::LoopInfo::ID); + } + }; } -void InductionVariableSimplify::getAnalysisUsageInfo(Pass::AnalysisSet &Req, - Pass::AnalysisSet &Dest, - Pass::AnalysisSet &Prov) { - Req.push_back(cfg::LoopInfo::ID); +Pass *createIndVarSimplifyPass() { + return new InductionVariableSimplify(); } + diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 31692502555..08cf74637e1 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -19,6 +19,7 @@ #include "llvm/Method.h" #include "llvm/iMemory.h" #include "llvm/InstrTypes.h" +#include "llvm/Pass.h" #include "llvm/Support/InstIterator.h" #include "../TransformInternals.h" @@ -37,7 +38,15 @@ static Instruction *CombineBinOp(BinaryOperator *I) { LocalChange = false; Value *Op1 = I->getOperand(0); if (Constant *Op2 = dyn_cast(I->getOperand(1))) { - if (I->getOpcode() == Instruction::Add) { + switch (I->getOpcode()) { + case Instruction::Add: + if (I->getType()->isIntegral() && cast(Op2)->equalsInt(0)){ + // Eliminate 'add int %X, 0' + I->replaceAllUsesWith(Op1); // FIXME: This breaks the worklist + LocalChange = true; + break; + } + if (Instruction *IOp1 = dyn_cast(Op1)) { if (IOp1->getOpcode() == Instruction::Add && isa(IOp1->getOperand(1))) { @@ -54,10 +63,23 @@ static Instruction *CombineBinOp(BinaryOperator *I) { I->setOperand(0, IOp1->getOperand(0)); I->setOperand(1, Val); LocalChange = true; + break; } } } + break; + + case Instruction::Mul: + if (I->getType()->isIntegral() && cast(Op2)->equalsInt(1)){ + // Eliminate 'mul int %X, 1' + I->replaceAllUsesWith(Op1); // FIXME: This breaks the worklist + LocalChange = true; + break; + } + + default: + break; } } Changed |= LocalChange; @@ -110,7 +132,7 @@ static Instruction *CombineIndicies(MemAccessInst *MAI) { return 0; } -bool InstructionCombining::CombineInstruction(Instruction *I) { +static bool CombineInstruction(Instruction *I) { Instruction *Result = 0; if (BinaryOperator *BOP = dyn_cast(I)) Result = CombineBinOp(BOP); @@ -125,8 +147,7 @@ bool InstructionCombining::CombineInstruction(Instruction *I) { return true; } - -bool InstructionCombining::doit(Method *M) { +static bool doInstCombining(Method *M) { // Start the worklist out with all of the instructions in the method in it. std::vector WorkList(inst_begin(M), inst_end(M)); @@ -148,3 +169,13 @@ bool InstructionCombining::doit(Method *M) { return false; } + +namespace { + struct InstructionCombining : public MethodPass { + virtual bool runOnMethod(Method *M) { return doInstCombining(M); } + }; +} + +Pass *createInstructionCombiningPass() { + return new InstructionCombining(); +} diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index ada670deb81..447a3e19600 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -25,6 +25,7 @@ #include "llvm/iMemory.h" #include "llvm/iTerminators.h" #include "llvm/iOther.h" +#include "llvm/Pass.h" #include "llvm/Assembly/Writer.h" #include "Support/STLExtras.h" #include @@ -503,11 +504,18 @@ void SCCP::OperandChangedState(User *U) { UpdateInstruction(I); } +namespace { + // SCCPPass - Use Sparse Conditional Constant Propogation + // to prove whether a value is constant and whether blocks are used. + // + struct SCCPPass : public MethodPass { + inline bool runOnMethod(Method *M) { + SCCP S(M); + return S.doSCCP(); + } + }; +} -// DoSparseConditionalConstantProp - Use Sparse Conditional Constant Propogation -// to prove whether a value is constant and whether blocks are used. -// -bool SCCPPass::doSCCP(Method *M) { - SCCP S(M); - return S.doSCCP(); +Pass *createSCCPPass() { + return new SCCPPass(); } diff --git a/lib/Transforms/Scalar/SymbolStripping.cpp b/lib/Transforms/Scalar/SymbolStripping.cpp index 12f8e918b3f..8502082a15d 100644 --- a/lib/Transforms/Scalar/SymbolStripping.cpp +++ b/lib/Transforms/Scalar/SymbolStripping.cpp @@ -18,6 +18,7 @@ #include "llvm/Module.h" #include "llvm/Method.h" #include "llvm/SymbolTable.h" +#include "llvm/Pass.h" static bool StripSymbolTable(SymbolTable *SymTab) { if (SymTab == 0) return false; // No symbol table? No problem. @@ -44,16 +45,38 @@ static bool StripSymbolTable(SymbolTable *SymTab) { // DoSymbolStripping - Remove all symbolic information from a method // -bool SymbolStripping::doSymbolStripping(Method *M) { +static bool 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 FullSymbolStripping::doStripGlobalSymbols(Module *M) { +static bool doStripGlobalSymbols(Module *M) { // Remove all symbols from methods in this module... and then strip all of the // symbols in this module... // return StripSymbolTable(M->getSymbolTable()); } + +namespace { + struct SymbolStripping : public MethodPass { + virtual bool runOnMethod(Method *M) { + return doSymbolStripping(M); + } + }; + + struct FullSymbolStripping : public SymbolStripping { + virtual bool doInitialization(Module *M) { + return doStripGlobalSymbols(M); + } + }; +} + +Pass *createSymbolStrippingPass() { + return new SymbolStripping(); +} + +Pass *createFullSymbolStrippingPass() { + return new FullSymbolStripping(); +} diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index ff7a3674ec1..dc5137e1ff8 100644 --- a/lib/Transforms/Utils/LowerAllocations.cpp +++ b/lib/Transforms/Utils/LowerAllocations.cpp @@ -15,9 +15,57 @@ #include "llvm/iOther.h" #include "llvm/SymbolTable.h" #include "llvm/ConstantVals.h" +#include "llvm/Pass.h" #include "TransformInternals.h" using std::vector; +namespace { + +// LowerAllocations - Turn malloc and free instructions into %malloc and %free +// calls. +// +class LowerAllocations : public BasicBlockPass { + Method *MallocMeth; // Methods in the module we are processing + Method *FreeMeth; // Initialized by doInitialization + + const TargetData &DataLayout; +public: + inline LowerAllocations(const TargetData &TD) : DataLayout(TD) { + MallocMeth = FreeMeth = 0; + } + + // doPassInitialization - For the lower allocations pass, this ensures that a + // module contains a declaration for a malloc and a free function. + // + bool doInitialization(Module *M); + + // runOnBasicBlock - This method does the actual work of converting + // instructions over, assuming that the pass has already been initialized. + // + bool runOnBasicBlock(BasicBlock *BB); +}; + +// RaiseAllocations - Turn %malloc and %free calls into the appropriate +// instruction. +// +class RaiseAllocations : public BasicBlockPass { + Method *MallocMeth; // Methods in the module we are processing + Method *FreeMeth; // Initialized by doPassInitializationVirt +public: + inline RaiseAllocations() : MallocMeth(0), FreeMeth(0) {} + + // doPassInitialization - For the raise allocations pass, this finds a + // declaration for malloc and free if they exist. + // + bool doInitialization(Module *M); + + // runOnBasicBlock - This method does the actual work of converting + // instructions over, assuming that the pass has already been initialized. + // + bool runOnBasicBlock(BasicBlock *BB); +}; + +} // end anonymous namespace // doInitialization - For the lower allocations pass, this ensures that a // module contains a declaration for a malloc and a free function. @@ -181,3 +229,12 @@ bool RaiseAllocations::runOnBasicBlock(BasicBlock *BB) { return Changed; } + +Pass *createLowerAllocationsPass(const TargetData &TD) { + return new LowerAllocations(TD); +} +Pass *createRaiseAllocationsPass() { + return new RaiseAllocations(); +} + + diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index 2b2447b155b..69a0774a2ff 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -53,27 +53,7 @@ enum Opts { globaldce, swapstructs, sortstructs, }; - -// New template functions - Provide functions that return passes of specified -// types, with specified arguments... -// -template -Pass *New() { - return new PassClass(); -} - -template -Pass *New() { - return new PassClass(Arg1); -} - -template -Pass *New() { - return new PassClass(Arg1, Arg2); -} - -static Pass *NewPrintMethodPass() { +static Pass *createPrintMethodPass() { return new PrintMethodPass("Current Method: \n", &cerr); } @@ -83,35 +63,33 @@ struct { enum Opts OptID; Pass * (*PassCtor)(); } OptTable[] = { - { dce , New }, - { constprop , New }, - { inlining , New }, - { constmerge , New }, - { strip , New }, - { mstrip , New }, - { mergereturn, New }, - - { indvars , New }, - { instcombine, New }, - { sccp , New }, - { adce , New }, - { raise , New }, + { dce , createDeadCodeEliminationPass }, + { constprop , createConstantPropogationPass }, + { inlining , createMethodInliningPass }, + { constmerge , createConstantMergePass }, + { strip , createSymbolStrippingPass }, + { mstrip , createFullSymbolStrippingPass }, + { mergereturn, createUnifyMethodExitNodesPass }, + + { indvars , createIndVarSimplifyPass }, + { instcombine, createInstructionCombiningPass }, + { sccp , createSCCPPass }, + { adce , createAgressiveDCEPass }, + { raise , createRaisePointerReferencesPass }, { mem2reg , newPromoteMemoryToRegister }, - { trace , New }, - { tracem , New }, + { trace , createTraceValuesPassForBasicBlocks }, + { tracem , createTraceValuesPassForMethod }, { paths , createProfilePathsPass }, - { print , NewPrintMethodPass }, + { print , createPrintMethodPass }, { verify , createVerifierPass }, - { raiseallocs, New }, - { cleangcc , New }, - { globaldce , New }, - { swapstructs, New}, - { sortstructs, New}, + { raiseallocs, createRaiseAllocationsPass }, + { cleangcc , createCleanupGCCOutputPass }, + { globaldce , createGlobalDCEPass }, + { swapstructs, createSwapElementsPass }, + { sortstructs, createSortElementsPass }, }; // Command line option handling code... -- 2.34.1