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
diff --git a/include/llvm/Transforms/ChangeAllocations.h b/include/llvm/Transforms/ChangeAllocations.h
index f0a0685..1b83741 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 2524897..e321df5 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 27bf7ab..3a1bab1 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 313aea2..3cc4e76 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 efc91f4..b25fb66 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<Constant*, GlobalVariable*> 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 497416c..8956fc3 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 f159c4d..ccfcea7 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 996db17..0519e1d 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 b652f33..ec2ce31 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 c4d9735..3a8fa5b 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);
+//===----------------------------------------------------------------------===//
+// Normal Constant Propogation Pass
+//
+Pass *createConstantPropogationPass();
- // 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);
- }
-};
-
-
+// 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 @@
//===----------------------------------------------------------------------===//
// 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 3246ed8..a8dcb59 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 @@
// 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 @@
// 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 902483e..4fda9e7 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 0c39572..37b4985 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 156e211..f9b7c60 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 e923b92..4c87b09 100644
--- a/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
+++ b/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
@@ -40,4 +40,8 @@
}
};
+static inline Pass *createUnifyMethodExitNodesPass() {
+ return new UnifyMethodExitNodes();
+}
+
#endif
diff --git a/lib/Transforms/HoistPHIConstants.cpp b/lib/Transforms/HoistPHIConstants.cpp
index 43ed725..f20de1c 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 <map>
#include <vector>
@@ -19,12 +20,6 @@
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 @@
// 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 @@
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 0951c73..d78d185 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 @@
return MadeChanges;
}
-
-// mergeDuplicateConstants - Static accessor for clients that don't want to
-// deal with passes.
-//
-bool ConstantMerge::mergeDuplicateConstants(Module *M) {
- std::map<Constant*, GlobalVariable*> Constants;
- unsigned LastConstantSeen = 0;
- return ::mergeDuplicateConstants(M, LastConstantSeen, Constants);
+namespace {
+ // FIXME: ConstantMerge should not be a methodPass!!!
+ class ConstantMerge : public MethodPass {
+ protected:
+ std::map<Constant*, GlobalVariable*> 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);
+ }
+ };
}
-
-// 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);
-}
-
-// 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 09d8db4..801cdff 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 <algorithm>
#include <iostream>
using std::vector;
@@ -31,6 +32,36 @@
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 @@
// 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 @@
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 1b64a0b..454f601 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 <set>
@@ -45,18 +46,27 @@
return true;
}
-bool GlobalDCE::run(Module *M) {
- return RemoveUnreachableMethods(M, getAnalysis<cfg::CallGraph>());
+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<cfg::CallGraph>());
+ }
+
+ // 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);
+ }
+ };
}
-// 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);
-}
+Pass *createGlobalDCEPass() { return new GlobalDCE(); }
diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp
index d4c23a9..9ca23f7 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 @@
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 @@
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 8583e3e..168f839 100644
--- a/lib/Transforms/IPO/SimpleStructMutation.cpp
+++ b/lib/Transforms/IPO/SimpleStructMutation.cpp
@@ -19,6 +19,37 @@
#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 @@
}
}
+
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 @@
}
-// 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 aad63c8..6e4fedc 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 <sstream>
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 ef0a5fd..2826e9f 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 @@
#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 @@
}
-
-
// 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 @@
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 91bed41..14c68f4 100644
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -288,21 +288,24 @@
}
}
-
-
-// doADCE - Execute the Agressive Dead Code Elimination Algorithm
-//
-bool AgressiveDCE::runOnMethod(Method *M) {
- return ADCE(M).doADCE(
- getAnalysis<cfg::DominanceFrontier>(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>(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 190bd4b..fc4e3bf 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 @@
// 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<BinaryOperator>(Inst)) {
Constant *D1 = dyn_cast<Constant>(Inst->getOperand(0));
@@ -200,7 +200,7 @@
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 @@
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;
-
- return Modified;
+ // Fold constants until we make no progress...
+ while (DoConstPropPass(M)) Modified = true;
+
+ return Modified;
+ }
+ };
}
+
+Pass *createConstantPropogationPass() {
+ return new ConstantPropogation();
+}
+
diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp
index 8f351a1..491c957 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 <algorithm>
@@ -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<TerminatorInst>(*BBI)) {
@@ -55,15 +56,21 @@
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 @@
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 @@
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 692fcac..fcf49e1 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 @@
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<cfg::LoopInfo>());
+
+namespace {
+ struct InductionVariableSimplify : public MethodPass {
+ virtual bool runOnMethod(Method *M) {
+ return doit(M, getAnalysis<cfg::LoopInfo>());
+ }
+
+ 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 3169250..08cf746 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 @@
LocalChange = false;
Value *Op1 = I->getOperand(0);
if (Constant *Op2 = dyn_cast<Constant>(I->getOperand(1))) {
- if (I->getOpcode() == Instruction::Add) {
+ switch (I->getOpcode()) {
+ case Instruction::Add:
+ if (I->getType()->isIntegral() && cast<ConstantInt>(Op2)->equalsInt(0)){
+ // Eliminate 'add int %X, 0'
+ I->replaceAllUsesWith(Op1); // FIXME: This breaks the worklist
+ LocalChange = true;
+ break;
+ }
+
if (Instruction *IOp1 = dyn_cast<Instruction>(Op1)) {
if (IOp1->getOpcode() == Instruction::Add &&
isa<Constant>(IOp1->getOperand(1))) {
@@ -54,10 +63,23 @@
I->setOperand(0, IOp1->getOperand(0));
I->setOperand(1, Val);
LocalChange = true;
+ break;
}
}
}
+ break;
+
+ case Instruction::Mul:
+ if (I->getType()->isIntegral() && cast<ConstantInt>(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 @@
return 0;
}
-bool InstructionCombining::CombineInstruction(Instruction *I) {
+static bool CombineInstruction(Instruction *I) {
Instruction *Result = 0;
if (BinaryOperator *BOP = dyn_cast<BinaryOperator>(I))
Result = CombineBinOp(BOP);
@@ -125,8 +147,7 @@
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<Instruction*> WorkList(inst_begin(M), inst_end(M));
@@ -148,3 +169,13 @@
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 ada670d..447a3e1 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 <algorithm>
@@ -503,11 +504,18 @@
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 12f8e91..8502082 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 @@
// 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 ff7a367..dc5137e 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 @@
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 2b2447b..69a0774 100644
--- a/tools/opt/opt.cpp
+++ b/tools/opt/opt.cpp
@@ -53,27 +53,7 @@
globaldce, swapstructs, sortstructs,
};
-
-// New template functions - Provide functions that return passes of specified
-// types, with specified arguments...
-//
-template<class PassClass>
-Pass *New() {
- return new PassClass();
-}
-
-template<class PassClass, typename ArgTy1, ArgTy1 Arg1>
-Pass *New() {
- return new PassClass(Arg1);
-}
-
-template<class PassClass, typename ArgTy1, ArgTy1 Arg1,
- typename ArgTy2, ArgTy1 Arg2>
-Pass *New() {
- return new PassClass(Arg1, Arg2);
-}
-
-static Pass *NewPrintMethodPass() {
+static Pass *createPrintMethodPass() {
return new PrintMethodPass("Current Method: \n", &cerr);
}
@@ -83,35 +63,33 @@
enum Opts OptID;
Pass * (*PassCtor)();
} OptTable[] = {
- { dce , New<DeadCodeElimination> },
- { constprop , New<ConstantPropogation> },
- { inlining , New<MethodInlining> },
- { constmerge , New<ConstantMerge> },
- { strip , New<SymbolStripping> },
- { mstrip , New<FullSymbolStripping> },
- { mergereturn, New<UnifyMethodExitNodes> },
+ { dce , createDeadCodeEliminationPass },
+ { constprop , createConstantPropogationPass },
+ { inlining , createMethodInliningPass },
+ { constmerge , createConstantMergePass },
+ { strip , createSymbolStrippingPass },
+ { mstrip , createFullSymbolStrippingPass },
+ { mergereturn, createUnifyMethodExitNodesPass },
- { indvars , New<InductionVariableSimplify> },
- { instcombine, New<InstructionCombining> },
- { sccp , New<SCCPPass> },
- { adce , New<AgressiveDCE> },
- { raise , New<RaisePointerReferences> },
+ { indvars , createIndVarSimplifyPass },
+ { instcombine, createInstructionCombiningPass },
+ { sccp , createSCCPPass },
+ { adce , createAgressiveDCEPass },
+ { raise , createRaisePointerReferencesPass },
{ mem2reg , newPromoteMemoryToRegister },
- { trace , New<InsertTraceCode, bool, true, bool, true> },
- { tracem , New<InsertTraceCode, bool, false, bool, true> },
+ { trace , createTraceValuesPassForBasicBlocks },
+ { tracem , createTraceValuesPassForMethod },
{ paths , createProfilePathsPass },
- { print , NewPrintMethodPass },
+ { print , createPrintMethodPass },
{ verify , createVerifierPass },
- { raiseallocs, New<RaiseAllocations> },
- { cleangcc , New<CleanupGCCOutput> },
- { globaldce , New<GlobalDCE> },
- { swapstructs, New<SimpleStructMutation, SimpleStructMutation::Transform,
- SimpleStructMutation::SwapElements>},
- { sortstructs, New<SimpleStructMutation, SimpleStructMutation::Transform,
- SimpleStructMutation::SortElements>},
+ { raiseallocs, createRaiseAllocationsPass },
+ { cleangcc , createCleanupGCCOutputPass },
+ { globaldce , createGlobalDCEPass },
+ { swapstructs, createSwapElementsPass },
+ { sortstructs, createSortElementsPass },
};
// Command line option handling code...