diff options
32 files changed, 238 insertions, 208 deletions
diff --git a/include/llvm/Analysis/FindUnsafePointerTypes.h b/include/llvm/Analysis/FindUnsafePointerTypes.h index c52ca2fbbb..4b2251d905 100644 --- a/include/llvm/Analysis/FindUnsafePointerTypes.h +++ b/include/llvm/Analysis/FindUnsafePointerTypes.h @@ -22,7 +22,7 @@ class PointerType; -struct FindUnsafePointerTypes : public Pass { +struct FindUnsafePointerTypes : public MethodPass { // UnsafeTypes - Set of types that are not safe to transform. std::set<PointerType*> UnsafeTypes; public: @@ -32,11 +32,11 @@ public: return UnsafeTypes; } - // doPerMethodWork - Inspect the operations that the specified method does on + // runOnMethod - Inspect the operations that the specified method does on // values of various types. If they are deemed to be 'unsafe' note that the // type is not safe to transform. // - virtual bool doPerMethodWork(Method *M); + virtual bool runOnMethod(Method *M); // printResults - Loop over the results of the analysis, printing out unsafe // types. diff --git a/include/llvm/Analysis/FindUsedTypes.h b/include/llvm/Analysis/FindUsedTypes.h index 956901dfaa..1005042ab9 100644 --- a/include/llvm/Analysis/FindUsedTypes.h +++ b/include/llvm/Analysis/FindUsedTypes.h @@ -11,7 +11,7 @@ #include <set> class SymbolTable; -class FindUsedTypes : public Pass { +class FindUsedTypes : public MethodPass { std::set<const Type *> UsedTypes; bool IncludeSymbolTables; @@ -45,14 +45,14 @@ private: void IncorporateSymbolTable(const SymbolTable *ST); public: - // doPassInitialization - This loops over global constants defined in the + // doInitialization - This loops over global constants defined in the // module, converting them to their new type. // - bool doPassInitialization(Module *M); + bool doInitialization(Module *M); - // doPerMethodWork - This incorporates all types used by the specified method + // runOnMethod - This incorporates all types used by the specified method // - bool doPerMethodWork(Method *M); + bool runOnMethod(Method *M); }; #endif diff --git a/include/llvm/Assembly/PrintModulePass.h b/include/llvm/Assembly/PrintModulePass.h index 72d8fabde0..181ce98227 100644 --- a/include/llvm/Assembly/PrintModulePass.h +++ b/include/llvm/Assembly/PrintModulePass.h @@ -1,7 +1,9 @@ //===- llvm/Assembly/PrintModulePass.h - Printing Pass -----------*- C++ -*--=// // -// This file defines a simple pass to print out methods of a module as they are -// processed. +// This file defines two passes to print out a module. The PrintModulePass +// pass simply prints out the entire module when it is executed. The +// PrintMethodPass class is designed to be pipelined with other MethodPass's, +// and prints out the methods of the class as they are processed. // //===----------------------------------------------------------------------===// @@ -13,36 +15,42 @@ #include <iostream> class PrintModulePass : public Pass { - std::string Banner; // String to print before each method std::ostream *Out; // ostream to print on bool DeleteStream; // Delete the ostream in our dtor? - bool PrintPerMethod; // Print one method at a time rather than the whole? public: - inline PrintModulePass(const std::string &B, std::ostream *o = &std::cout, - bool DS = false, - bool printPerMethod = true) - : Banner(B), Out(o), DeleteStream(DS), PrintPerMethod(printPerMethod) { + inline PrintModulePass(std::ostream *o = &std::cout, bool DS = false) + : Out(o), DeleteStream(DS) { } inline ~PrintModulePass() { if (DeleteStream) delete Out; } - // doPerMethodWork - This pass just prints a banner followed by the method as - // it's processed. - // - bool doPerMethodWork(Method *M) { - if (PrintPerMethod) - (*Out) << Banner << M; + bool run(Module *M) { + (*Out) << M; return false; } +}; - // doPassFinalization - Virtual method overriden by subclasses to do any post - // processing needed after all passes have run. +class PrintMethodPass : public MethodPass { + std::string Banner; // String to print before each method + std::ostream *Out; // ostream to print on + bool DeleteStream; // Delete the ostream in our dtor? +public: + inline PrintMethodPass(const std::string &B, std::ostream *o = &std::cout, + bool DS = false) + : Banner(B), Out(o), DeleteStream(DS) { + } + + inline ~PrintMethodPass() { + if (DeleteStream) delete Out; + } + + // runOnMethod - This pass just prints a banner followed by the method as + // it's processed. // - bool doPassFinalization(Module *M) { - if (! PrintPerMethod) - (*Out) << Banner << M; + bool runOnMethod(Method *M) { + (*Out) << Banner << M; return false; } }; diff --git a/include/llvm/Bytecode/WriteBytecodePass.h b/include/llvm/Bytecode/WriteBytecodePass.h index 6a0edbcd99..bd9d42369e 100644 --- a/include/llvm/Bytecode/WriteBytecodePass.h +++ b/include/llvm/Bytecode/WriteBytecodePass.h @@ -23,7 +23,7 @@ public: if (DeleteStream) delete Out; } - bool doPassFinalization(Module *M) { + bool run(Module *M) { WriteBytecodeToFile(M, *Out); return false; } diff --git a/include/llvm/Transforms/ChangeAllocations.h b/include/llvm/Transforms/ChangeAllocations.h index 8f53051da3..05fb133410 100644 --- a/include/llvm/Transforms/ChangeAllocations.h +++ b/include/llvm/Transforms/ChangeAllocations.h @@ -13,7 +13,7 @@ #include "llvm/Pass.h" class TargetData; -class LowerAllocations : public Pass { +class LowerAllocations : public MethodPass { Method *MallocMeth; // Methods in the module we are processing Method *FreeMeth; // Initialized by doPassInitializationVirt @@ -28,12 +28,12 @@ public: // // This function is always successful. // - bool doPassInitialization(Module *M); + bool doInitialization(Module *M); // doPerMethodWork - This method does the actual work of converting // instructions over, assuming that the pass has already been initialized. // - bool doPerMethodWork(Method *M); + bool runOnMethod(Method *M); }; #endif diff --git a/include/llvm/Transforms/FunctionInlining.h b/include/llvm/Transforms/FunctionInlining.h index 520cc7fe6c..abc08fdbad 100644 --- a/include/llvm/Transforms/FunctionInlining.h +++ b/include/llvm/Transforms/FunctionInlining.h @@ -13,13 +13,13 @@ class CallInst; namespace opt { -struct MethodInlining : public 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 doPerMethodWork(Method *M) { + virtual bool runOnMethod(Method *M) { return doMethodInlining(M); } }; diff --git a/include/llvm/Transforms/HoistPHIConstants.h b/include/llvm/Transforms/HoistPHIConstants.h index 65bae751a8..27bf7ab021 100644 --- a/include/llvm/Transforms/HoistPHIConstants.h +++ b/include/llvm/Transforms/HoistPHIConstants.h @@ -11,12 +11,12 @@ #include "llvm/Pass.h" -struct HoistPHIConstants : public Pass { +struct HoistPHIConstants : public MethodPass { // doHoistPHIConstants - Hoist constants out of PHI instructions // static bool doHoistPHIConstants(Method *M); - virtual bool doPerMethodWork(Method *M) { return doHoistPHIConstants(M); } + virtual bool runOnMethod(Method *M) { return doHoistPHIConstants(M); } }; #endif diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h index 99ff169a1a..6bdba2241d 100644 --- a/include/llvm/Transforms/IPO.h +++ b/include/llvm/Transforms/IPO.h @@ -8,7 +8,7 @@ #include "llvm/Analysis/FindUsedTypes.h" -class CleanupGCCOutput : public Pass { +class CleanupGCCOutput : public MethodPass { Method *Malloc, *Free; // Pointers to external declarations, or null if none FindUsedTypes FUT; // Use FUT to eliminate type names that are never used public: @@ -27,14 +27,14 @@ public: // // Also, initialize instance variables. // - bool doPassInitialization(Module *M); + bool doInitialization(Module *M); // doPerMethodWork - This method simplifies the specified method hopefully. // - bool doPerMethodWork(Method *M); + bool runOnMethod(Method *M); // doPassFinalization - Strip out type names that are unused by the program - bool doPassFinalization(Module *M); + bool doFinalization(Module *M); private: bool doOneCleanupPass(Method *M); }; diff --git a/include/llvm/Transforms/IPO/ConstantMerge.h b/include/llvm/Transforms/IPO/ConstantMerge.h index 37d830ccf8..54f699a811 100644 --- a/include/llvm/Transforms/IPO/ConstantMerge.h +++ b/include/llvm/Transforms/IPO/ConstantMerge.h @@ -22,7 +22,8 @@ class Constant; class GlobalVariable; -class ConstantMerge : public Pass { +// FIXME: ConstantMerge should not be a methodPass!!! +class ConstantMerge : public MethodPass { protected: std::map<Constant*, GlobalVariable*> Constants; unsigned LastConstantSeen; @@ -34,14 +35,16 @@ public: // static bool mergeDuplicateConstants(Module *M); - // doPassInitialization - For this pass, process all of the globals in the + // doInitialization - For this pass, process all of the globals in the // module, eliminating duplicate constants. // - bool doPassInitialization(Module *M); + bool doInitialization(Module *M); - // doPassFinalization - Clean up internal state for this module + bool runOnMethod(Method*) { return false; } + + // doFinalization - Clean up internal state for this module // - bool doPassFinalization(Module *M) { + bool doFinalization(Module *M) { LastConstantSeen = 0; Constants.clear(); return false; @@ -52,7 +55,7 @@ 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 doPerMethodWork(Method *M); + bool runOnMethod(Method *M); }; #endif diff --git a/include/llvm/Transforms/IPO/GlobalDCE.h b/include/llvm/Transforms/IPO/GlobalDCE.h index 5491751b54..c4c74470de 100644 --- a/include/llvm/Transforms/IPO/GlobalDCE.h +++ b/include/llvm/Transforms/IPO/GlobalDCE.h @@ -7,15 +7,17 @@ #ifndef LLVM_TRANSFORM_IPO_GLOBALDCE_H #define LLVM_TRANSFORM_IPO_GLOBALDCE_H +#include "llvm/Pass.h" + namespace cfg { class CallGraph; } class Module; -struct GlobalDCE { +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, cfg::CallGraph *CG = 0); + bool run(Module *M); }; #endif diff --git a/include/llvm/Transforms/IPO/SimpleStructMutation.h b/include/llvm/Transforms/IPO/SimpleStructMutation.h index 77b962b107..181996d45b 100644 --- a/include/llvm/Transforms/IPO/SimpleStructMutation.h +++ b/include/llvm/Transforms/IPO/SimpleStructMutation.h @@ -1,22 +1,27 @@ -//===- llvm/Transforms/SwapStructContents.h - Permute Structs ----*- C++ -*--=// +//===- llvm/Transforms/SimpleStructMutation.h - Permute Structs --*- C++ -*--=// // -// This pass does a simple transformation that swaps all of the elements of the -// struct types in the program around. +// This pass does is a wrapper that can do a few simple structure mutation +// transformations. // //===----------------------------------------------------------------------===// -#ifndef LLVM_TRANSFORMS_SWAPSTRUCTCONTENTS_H -#define LLVM_TRANSFORMS_SWAPSTRUCTCONTENTS_H +#ifndef LLVM_TRANSFORMS_SIMPLESTRUCTMUTATION_H +#define LLVM_TRANSFORMS_SIMPLESTRUCTMUTATION_H #include "llvm/Transforms/MutateStructTypes.h" -// FIXME: Move to correct location! -class PrebuiltStructMutation : public MutateStructTypes { +class SimpleStructMutation : public MutateStructTypes { public: - enum Transform { SwapElements, SortElements }; + enum Transform { SwapElements, SortElements } CurrentXForm; - PrebuiltStructMutation(Module *M, enum Transform XForm) - : MutateStructTypes(getTransforms(M, XForm)) {} + SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {} + + virtual bool run(Module *M) { + setTransforms(getTransforms(M, CurrentXForm)); + bool Changed = MutateStructTypes::run(M); + clearTransforms(); + return Changed; + } private: static TransformsType getTransforms(Module *M, enum Transform); diff --git a/include/llvm/Transforms/Instrumentation/TraceValues.h b/include/llvm/Transforms/Instrumentation/TraceValues.h index 13847161f1..996db1747e 100644 --- a/include/llvm/Transforms/Instrumentation/TraceValues.h +++ b/include/llvm/Transforms/Instrumentation/TraceValues.h @@ -11,7 +11,7 @@ #include "llvm/Pass.h" class Method; -class InsertTraceCode : public Pass { +class InsertTraceCode : public MethodPass { bool TraceBasicBlockExits, TraceMethodExits; Method *PrintfMeth; public: @@ -21,7 +21,7 @@ public: // Add a prototype for printf if it is not already in the program. // - bool doPassInitialization(Module *M); + bool doInitialization(Module *M); //-------------------------------------------------------------------------- // Function InsertCodeToTraceValues @@ -32,9 +32,9 @@ public: static bool doit(Method *M, bool traceBasicBlockExits, bool traceMethodExits, Method *Printf); - // doPerMethodWork - This method does the work. Always successful. + // runOnMethod - This method does the work. Always successful. // - bool doPerMethodWork(Method *M) { + bool runOnMethod(Method *M) { return doit(M, TraceBasicBlockExits, TraceMethodExits, PrintfMeth); } }; diff --git a/include/llvm/Transforms/MutateStructTypes.h b/include/llvm/Transforms/MutateStructTypes.h index 23bf71c3b1..390168f645 100644 --- a/include/llvm/Transforms/MutateStructTypes.h +++ b/include/llvm/Transforms/MutateStructTypes.h @@ -51,25 +51,40 @@ public: // typedef std::map<const StructType*, std::vector<int> > TransformsType; - MutateStructTypes(const TransformsType &Transforms); + MutateStructTypes(const TransformsType &Transforms) { + setTransforms(Transforms); + } + // run - do the transformation + virtual bool run(Module *M); - // doPassInitialization - This loops over global constants defined in the +protected: + + // Alternatively, it is valid to subclass this class and provide transforms + // this way. See SimpleStructMutation for an example. + // + MutateStructTypes() {} + void setTransforms(const TransformsType &Transforms); + void clearTransforms(); + +private: + + // processGlobals - This loops over global constants defined in the // module, converting them to their new type. Also this creates placeholder // methods for methods than need to be copied because they have a new // signature type. // - bool doPassInitialization(Module *M); + void processGlobals(Module *M); - // doPerMethodWork - This transforms the instructions of the method to use the + // transformMethod - This transforms the instructions of the method to use the // new types. // - bool doPerMethodWork(Method *M); + void transformMethod(Method *M); - // doPassFinalization - This removes the old versions of methods that are no + // removeDeadGlobals - This removes the old versions of methods that are no // longer needed. // - virtual bool doPassFinalization(Module *M); + void removeDeadGlobals(Module *M); private: // ConvertType - Convert from the old type system to the new one... diff --git a/include/llvm/Transforms/RaisePointerReferences.h b/include/llvm/Transforms/RaisePointerReferences.h index 593ccf2496..b652f33712 100644 --- a/include/llvm/Transforms/RaisePointerReferences.h +++ b/include/llvm/Transforms/RaisePointerReferences.h @@ -15,10 +15,10 @@ // expressions as possible, by converting expressions to use getelementptr and // friends. // -struct RaisePointerReferences : public Pass { +struct RaisePointerReferences : public MethodPass { static bool doit(Method *M); - virtual bool doPerMethodWork(Method *M) { return doit(M); } + virtual bool runOnMethod(Method *M) { return doit(M); } }; @@ -26,10 +26,10 @@ struct RaisePointerReferences : public Pass { // converts all induction variables to reference a cannonical induction // variable (which starts at 0 and counts by 1). // -struct EliminateAuxillaryInductionVariables : public Pass { +struct EliminateAuxillaryInductionVariables : public MethodPass { static bool doit(Method *M) { return false; } // TODO! - virtual bool doPerMethodWork(Method *M) { return doit(M); } + virtual bool runOnMethod(Method *M) { return doit(M); } }; #endif diff --git a/include/llvm/Transforms/Scalar/ConstantProp.h b/include/llvm/Transforms/Scalar/ConstantProp.h index e77a9c0600..f4418665f9 100644 --- a/include/llvm/Transforms/Scalar/ConstantProp.h +++ b/include/llvm/Transforms/Scalar/ConstantProp.h @@ -12,7 +12,7 @@ class TerminatorInst; namespace opt { -struct ConstantPropogation : public Pass { +struct ConstantPropogation : public MethodPass { // doConstantPropogation - Do trivial constant propogation and expression // folding static bool doConstantPropogation(Method *M); @@ -22,7 +22,7 @@ struct ConstantPropogation : public Pass { // static bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &I); - inline bool doPerMethodWork(Method *M) { + inline bool runOnMethod(Method *M) { return doConstantPropogation(M); } }; @@ -39,10 +39,10 @@ bool ConstantFoldTerminator(TerminatorInst *T); //===----------------------------------------------------------------------===// // Sparse Conditional Constant Propogation Pass // -struct SCCPPass : public Pass { +struct SCCPPass : public MethodPass { static bool doSCCP(Method *M); - inline bool doPerMethodWork(Method *M) { + inline bool runOnMethod(Method *M) { return doSCCP(M); } }; diff --git a/include/llvm/Transforms/Scalar/DCE.h b/include/llvm/Transforms/Scalar/DCE.h index 86943ebd85..0e9c620548 100644 --- a/include/llvm/Transforms/Scalar/DCE.h +++ b/include/llvm/Transforms/Scalar/DCE.h @@ -13,7 +13,7 @@ namespace opt { -struct DeadCodeElimination : public Pass { +struct DeadCodeElimination : public MethodPass { // External Interface: // static bool doDCE(Method *M); @@ -33,23 +33,23 @@ struct DeadCodeElimination : public Pass { static bool RemoveUnusedGlobalValues(Module *M); // Pass Interface... - virtual bool doPassInitialization(Module *M) { + virtual bool doInitialization(Module *M) { return RemoveUnusedGlobalValues(M); } - virtual bool doPerMethodWork(Method *M) { return doDCE(M); } - virtual bool doPassFinalization(Module *M) { + virtual bool runOnMethod(Method *M) { return doDCE(M); } + virtual bool doFinalization(Module *M) { return RemoveUnusedGlobalValues(M); } }; -struct AgressiveDCE : public Pass { +struct AgressiveDCE : public MethodPass { // DoADCE - Execute the Agressive Dead Code Elimination Algorithm // static bool doADCE(Method *M); // Defined in ADCE.cpp - virtual bool doPerMethodWork(Method *M) { + virtual bool runOnMethod(Method *M) { return doADCE(M); } }; diff --git a/include/llvm/Transforms/Scalar/IndVarSimplify.h b/include/llvm/Transforms/Scalar/IndVarSimplify.h index 00a43b5ab8..13f811994b 100644 --- a/include/llvm/Transforms/Scalar/IndVarSimplify.h +++ b/include/llvm/Transforms/Scalar/IndVarSimplify.h @@ -10,10 +10,10 @@ #include "llvm/Pass.h" -struct InductionVariableSimplify : public Pass { +struct InductionVariableSimplify : public MethodPass { static bool doit(Method *M); - virtual bool doPerMethodWork(Method *M) { return doit(M); } + virtual bool runOnMethod(Method *M) { return doit(M); } }; #endif diff --git a/include/llvm/Transforms/Scalar/InductionVars.h b/include/llvm/Transforms/Scalar/InductionVars.h index 82ec9fcc75..146239d82b 100644 --- a/include/llvm/Transforms/Scalar/InductionVars.h +++ b/include/llvm/Transforms/Scalar/InductionVars.h @@ -12,12 +12,12 @@ namespace opt { -struct InductionVariableCannonicalize : public Pass { +struct InductionVariableCannonicalize : public MethodPass { // doInductionVariableCannonicalize - Simplify induction variables in loops // static bool doIt(Method *M); - virtual bool doPerMethodWork(Method *M) { + virtual bool runOnMethod(Method *M) { return doIt(M); } }; diff --git a/include/llvm/Transforms/Scalar/InstructionCombining.h b/include/llvm/Transforms/Scalar/InstructionCombining.h index 09762d1552..c79a1caf4b 100644 --- a/include/llvm/Transforms/Scalar/InstructionCombining.h +++ b/include/llvm/Transforms/Scalar/InstructionCombining.h @@ -17,11 +17,11 @@ #include "llvm/Pass.h" -struct InstructionCombining : public Pass { +struct InstructionCombining : public MethodPass { static bool doit(Method *M); static bool CombineInstruction(Instruction *I); - virtual bool doPerMethodWork(Method *M) { return doit(M); } + virtual bool runOnMethod(Method *M) { return doit(M); } }; #endif diff --git a/include/llvm/Transforms/Scalar/SymbolStripping.h b/include/llvm/Transforms/Scalar/SymbolStripping.h index 1feb4381e9..ff31a4b532 100644 --- a/include/llvm/Transforms/Scalar/SymbolStripping.h +++ b/include/llvm/Transforms/Scalar/SymbolStripping.h @@ -12,28 +12,28 @@ namespace opt { -struct SymbolStripping : public Pass { +struct SymbolStripping : public MethodPass { // doSymbolStripping - Remove all symbolic information from a method // static bool doSymbolStripping(Method *M); - virtual bool doPerMethodWork(Method *M) { + virtual bool runOnMethod(Method *M) { return doSymbolStripping(M); } }; -struct FullSymbolStripping : public Pass { +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 doPassInitialization(Module *M) { + virtual bool doInitialization(Module *M) { return doStripGlobalSymbols(M); } - virtual bool doPerMethodWork(Method *M) { + virtual bool runOnMethod(Method *M) { return SymbolStripping::doSymbolStripping(M); } }; diff --git a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp index 1058e6ed39..85b5da8ce2 100644 --- a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp +++ b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp @@ -45,11 +45,11 @@ static inline bool isSafeInstruction(const Instruction *I) { } -// doPerMethodWork - Inspect the operations that the specified method does on +// runOnMethod - Inspect the operations that the specified method does on // values of various types. If they are deemed to be 'unsafe' note that the // type is not safe to transform. // -bool FindUnsafePointerTypes::doPerMethodWork(Method *Meth) { +bool FindUnsafePointerTypes::runOnMethod(Method *Meth) { const Method *M = Meth; // We don't need/want write access for (Method::const_inst_iterator I = M->inst_begin(), E = M->inst_end(); I != E; ++I) { diff --git a/lib/Analysis/IPA/FindUsedTypes.cpp b/lib/Analysis/IPA/FindUsedTypes.cpp index 1d98983115..c439407cb1 100644 --- a/lib/Analysis/IPA/FindUsedTypes.cpp +++ b/lib/Analysis/IPA/FindUsedTypes.cpp @@ -35,10 +35,10 @@ void FindUsedTypes::IncorporateSymbolTable(const SymbolTable *ST) { } -// doPassInitialization - This loops over global constants defined in the +// doInitialization - This loops over global constants defined in the // module, converting them to their new type. // -bool FindUsedTypes::doPassInitialization(Module *m) { +bool FindUsedTypes::doInitialization(Module *m) { const Module *M = m; if (IncludeSymbolTables && M->hasSymbolTable()) IncorporateSymbolTable(M->getSymbolTable()); // Add symtab first... @@ -51,7 +51,7 @@ bool FindUsedTypes::doPassInitialization(Module *m) { // doPerMethodWork - This incorporates all types used by the specified method // -bool FindUsedTypes::doPerMethodWork(Method *m) { +bool FindUsedTypes::runOnMethod(Method *m) { const Method *M = m; if (IncludeSymbolTables && M->hasSymbolTable()) IncorporateSymbolTable(M->getSymbolTable()); // Add symtab first... diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp index ff2442d2b6..acb3b6b937 100644 --- a/lib/Transforms/IPO/ConstantMerge.cpp +++ b/lib/Transforms/IPO/ConstantMerge.cpp @@ -65,16 +65,16 @@ bool ConstantMerge::mergeDuplicateConstants(Module *M) { } -// doPassInitialization - For this pass, process all of the globals in the +// doInitialization - For this pass, process all of the globals in the // module, eliminating duplicate constants. // -bool ConstantMerge::doPassInitialization(Module *M) { +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::doPerMethodWork(Method *M) { +bool DynamicConstantMerge::runOnMethod(Method *M) { return ::mergeDuplicateConstants(M->getParent(), LastConstantSeen, Constants); } diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index d5e9ea07bd..696f4bd7d7 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -220,14 +220,14 @@ static inline bool ShouldNukeSymtabEntry(const std::pair<string, Value*> &E) { return false; } -// doPassInitialization - For this pass, it removes global symbol table |