From 794fd75c67a2cdc128d67342c6d88a504d186896 Mon Sep 17 00:00:00 2001 From: Devang Patel Date: Tue, 1 May 2007 21:15:47 +0000 Subject: [PATCH] Do not use typeinfo to identify pass in pass manager. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36632 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/AliasAnalysis.h | 1 + include/llvm/Analysis/CallGraph.h | 1 + include/llvm/Analysis/Dominators.h | 27 +++++++++++------ include/llvm/Analysis/FindUsedTypes.h | 3 ++ include/llvm/Analysis/IntervalPartition.h | 4 ++- include/llvm/Analysis/LoopInfo.h | 3 ++ include/llvm/Analysis/LoopPass.h | 3 ++ include/llvm/Analysis/PostDominators.h | 12 ++++++-- include/llvm/Analysis/ProfileInfo.h | 1 + include/llvm/Analysis/ScalarEvolution.h | 3 +- include/llvm/Analysis/ValueNumbering.h | 1 + include/llvm/Assembly/PrintModulePass.h | 11 ++++--- include/llvm/Bytecode/WriteBytecodePass.h | 6 ++-- include/llvm/CallGraphSCCPass.h | 2 ++ include/llvm/CodeGen/AsmPrinter.h | 2 ++ include/llvm/CodeGen/LiveIntervalAnalysis.h | 3 ++ include/llvm/CodeGen/LiveVariables.h | 3 ++ include/llvm/CodeGen/MachineFunctionPass.h | 2 ++ include/llvm/CodeGen/MachineModuleInfo.h | 2 ++ include/llvm/CodeGen/SelectionDAGISel.h | 4 ++- include/llvm/Pass.h | 16 ++++++---- include/llvm/PassManagers.h | 4 ++- include/llvm/PassSupport.h | 26 ++++++++--------- include/llvm/Target/TargetData.h | 9 ++++-- include/llvm/Transforms/RSProfiling.h | 3 ++ .../Transforms/Utils/UnifyFunctionExitNodes.h | 4 ++- lib/Analysis/AliasAnalysis.cpp | 1 + lib/Analysis/AliasAnalysisCounter.cpp | 4 ++- lib/Analysis/AliasAnalysisEvaluator.cpp | 4 +++ lib/Analysis/AliasDebugger.cpp | 4 +++ lib/Analysis/AliasSetTracker.cpp | 4 +++ lib/Analysis/BasicAliasAnalysis.cpp | 6 ++++ lib/Analysis/CFGPrinter.cpp | 6 ++++ lib/Analysis/IPA/Andersens.cpp | 6 ++++ lib/Analysis/IPA/CallGraph.cpp | 6 +++- lib/Analysis/IPA/CallGraphSCCPass.cpp | 5 +++- lib/Analysis/IPA/FindUsedTypes.cpp | 1 + lib/Analysis/IPA/GlobalsModRef.cpp | 4 +++ lib/Analysis/InstCount.cpp | 4 +++ lib/Analysis/IntervalPartition.cpp | 4 ++- lib/Analysis/LoadValueNumbering.cpp | 3 ++ lib/Analysis/LoopInfo.cpp | 1 + lib/Analysis/LoopPass.cpp | 5 +++- lib/Analysis/PostDominators.cpp | 3 ++ lib/Analysis/ProfileInfo.cpp | 7 ++++- lib/Analysis/ProfileInfoLoaderPass.cpp | 4 ++- lib/Analysis/ScalarEvolution.cpp | 1 + lib/Analysis/ValueNumbering.cpp | 5 ++++ lib/Bytecode/Writer/Writer.cpp | 1 + lib/CodeGen/AsmPrinter.cpp | 3 +- lib/CodeGen/BranchFolding.cpp | 4 +++ lib/CodeGen/ELFWriter.cpp | 4 ++- lib/CodeGen/ELFWriter.h | 2 ++ lib/CodeGen/LiveIntervalAnalysis.cpp | 1 + lib/CodeGen/LiveVariables.cpp | 1 + lib/CodeGen/MachOWriter.cpp | 4 ++- lib/CodeGen/MachOWriter.h | 1 + lib/CodeGen/MachineFunction.cpp | 11 +++++-- lib/CodeGen/MachineModuleInfo.cpp | 9 +++++- lib/CodeGen/PHIElimination.cpp | 4 +++ lib/CodeGen/PrologEpilogInserter.cpp | 4 +++ lib/CodeGen/RegAllocLinearScan.cpp | 4 +++ lib/CodeGen/RegAllocLocal.cpp | 5 ++++ lib/CodeGen/RegAllocSimple.cpp | 6 +++- lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp | 2 ++ lib/CodeGen/TwoAddressInstructionPass.cpp | 4 +++ lib/CodeGen/UnreachableBlockElim.cpp | 4 +++ lib/Target/ARM/ARMConstantIslandPass.cpp | 4 +++ lib/Target/ARM/ARMLoadStoreOptimizer.cpp | 4 +++ lib/Target/Alpha/AlphaBranchSelector.cpp | 3 ++ lib/Target/Alpha/AlphaCodeEmitter.cpp | 6 ++-- lib/Target/Alpha/AlphaLLRP.cpp | 5 +++- lib/Target/CBackend/CBackend.cpp | 14 +++++++-- lib/Target/IA64/IA64Bundling.cpp | 5 +++- lib/Target/MSIL/MSILWriter.cpp | 2 ++ lib/Target/MSIL/MSILWriter.h | 7 +++-- lib/Target/PowerPC/PPCBranchSelector.cpp | 4 +++ lib/Target/PowerPC/PPCCodeEmitter.cpp | 4 ++- lib/Target/Sparc/DelaySlotFiller.cpp | 5 +++- lib/Target/Sparc/FPMover.cpp | 7 +++-- lib/Target/TargetData.cpp | 4 ++- lib/Target/X86/X86CodeEmitter.cpp | 8 +++-- lib/Target/X86/X86FloatingPoint.cpp | 4 +++ lib/Transforms/Hello/Hello.cpp | 9 ++++++ lib/Transforms/IPO/ArgumentPromotion.cpp | 4 +++ lib/Transforms/IPO/ConstantMerge.cpp | 4 +++ .../IPO/DeadArgumentElimination.cpp | 5 ++++ lib/Transforms/IPO/DeadTypeElimination.cpp | 4 +++ lib/Transforms/IPO/ExtractFunction.cpp | 6 +++- lib/Transforms/IPO/GlobalDCE.cpp | 4 +++ lib/Transforms/IPO/GlobalOpt.cpp | 3 ++ lib/Transforms/IPO/IPConstantPropagation.cpp | 4 +++ lib/Transforms/IPO/IndMemRemoval.cpp | 4 +++ lib/Transforms/IPO/InlineSimple.cpp | 2 ++ lib/Transforms/IPO/Inliner.cpp | 4 ++- lib/Transforms/IPO/Inliner.h | 1 + lib/Transforms/IPO/Internalize.cpp | 6 ++-- lib/Transforms/IPO/LoopExtractor.cpp | 15 ++++++++-- lib/Transforms/IPO/LowerSetJmp.cpp | 4 +++ lib/Transforms/IPO/PruneEH.cpp | 5 ++++ lib/Transforms/IPO/RaiseAllocations.cpp | 5 +++- lib/Transforms/IPO/SimplifyLibCalls.cpp | 4 +++ lib/Transforms/IPO/StripDeadPrototypes.cpp | 5 +++- lib/Transforms/IPO/StripSymbols.cpp | 6 +++- .../Instrumentation/BlockProfiling.cpp | 7 +++++ .../Instrumentation/EdgeProfiling.cpp | 4 +++ .../Instrumentation/RSProfiling.cpp | 7 +++++ lib/Transforms/Instrumentation/RSProfiling.h | 1 + lib/Transforms/Scalar/ADCE.cpp | 4 +++ lib/Transforms/Scalar/BasicBlockPlacement.cpp | 4 +++ lib/Transforms/Scalar/CodeGenPrepare.cpp | 6 +++- lib/Transforms/Scalar/CondPropagate.cpp | 5 ++++ lib/Transforms/Scalar/ConstantProp.cpp | 4 +++ lib/Transforms/Scalar/CorrelatedExprs.cpp | 5 ++++ lib/Transforms/Scalar/DCE.cpp | 7 +++++ .../Scalar/DeadStoreElimination.cpp | 3 ++ lib/Transforms/Scalar/GCSE.cpp | 4 +++ lib/Transforms/Scalar/IndVarSimplify.cpp | 7 ++++- .../Scalar/InstructionCombining.cpp | 4 +++ lib/Transforms/Scalar/LICM.cpp | 4 +++ lib/Transforms/Scalar/LoopRotation.cpp | 5 +++- lib/Transforms/Scalar/LoopStrengthReduce.cpp | 5 +++- lib/Transforms/Scalar/LoopUnroll.cpp | 4 +++ lib/Transforms/Scalar/LoopUnswitch.cpp | 4 +++ lib/Transforms/Scalar/LowerGC.cpp | 5 +++- lib/Transforms/Scalar/LowerPacked.cpp | 4 +++ lib/Transforms/Scalar/PredicateSimplifier.cpp | 4 +++ lib/Transforms/Scalar/Reassociate.cpp | 4 +++ lib/Transforms/Scalar/Reg2Mem.cpp | 3 ++ lib/Transforms/Scalar/SCCP.cpp | 7 +++++ .../Scalar/ScalarReplAggregates.cpp | 4 +++ lib/Transforms/Scalar/SimplifyCFG.cpp | 4 +++ lib/Transforms/Scalar/TailDuplication.cpp | 5 ++++ .../Scalar/TailRecursionElimination.cpp | 4 +++ lib/Transforms/Utils/BreakCriticalEdges.cpp | 4 +++ lib/Transforms/Utils/LCSSA.cpp | 4 +++ lib/Transforms/Utils/LoopSimplify.cpp | 4 +++ lib/Transforms/Utils/LowerAllocations.cpp | 5 +++- lib/Transforms/Utils/LowerInvoke.cpp | 5 +++- lib/Transforms/Utils/LowerSelect.cpp | 5 +++- lib/Transforms/Utils/LowerSwitch.cpp | 4 +++ lib/Transforms/Utils/Mem2Reg.cpp | 4 +++ .../Utils/UnifyFunctionExitNodes.cpp | 1 + lib/VMCore/AsmWriter.cpp | 2 ++ lib/VMCore/Dominators.cpp | 3 ++ lib/VMCore/Pass.cpp | 29 +++++++++---------- lib/VMCore/PassManager.cpp | 25 +++++++++++----- lib/VMCore/Verifier.cpp | 24 +++++++++------ tools/bugpoint/ExtractFunction.cpp | 4 +++ tools/bugpoint/TestPasses.cpp | 12 +++++++- tools/opt/AnalysisWrappers.cpp | 7 +++++ tools/opt/GraphPrinters.cpp | 4 +++ tools/opt/PrintSCC.cpp | 7 +++++ tools/opt/opt.cpp | 17 ++++++++--- 154 files changed, 687 insertions(+), 129 deletions(-) diff --git a/include/llvm/Analysis/AliasAnalysis.h b/include/llvm/Analysis/AliasAnalysis.h index f91403acb97..d61c886e7c1 100644 --- a/include/llvm/Analysis/AliasAnalysis.h +++ b/include/llvm/Analysis/AliasAnalysis.h @@ -61,6 +61,7 @@ protected: virtual void getAnalysisUsage(AnalysisUsage &AU) const; public: + static const int ID; // Class identification, replacement for typeinfo AliasAnalysis() : TD(0), AA(0) {} virtual ~AliasAnalysis(); // We want to be subclassed diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h index 24effd8d49d..cd27e318cd9 100644 --- a/include/llvm/Analysis/CallGraph.h +++ b/include/llvm/Analysis/CallGraph.h @@ -73,6 +73,7 @@ protected: FunctionMapTy FunctionMap; // Map from a function to its node public: + static const int ID; // Class identification, replacement for typeinfo //===--------------------------------------------------------------------- // Accessors... // diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h index 45eed7fcdaf..b172b792fca 100644 --- a/include/llvm/Analysis/Dominators.h +++ b/include/llvm/Analysis/Dominators.h @@ -42,9 +42,10 @@ class DominatorBase : public FunctionPass { protected: std::vector Roots; const bool IsPostDominators; - - inline DominatorBase(bool isPostDom) : Roots(), IsPostDominators(isPostDom) {} + inline DominatorBase(intptr_t ID, bool isPostDom) : + FunctionPass(ID), Roots(), IsPostDominators(isPostDom) {} public: + /// getRoots - Return the root blocks of the current CFG. This may include /// multiple blocks if we are computing post dominators. For forward /// dominators, this will always be a single block (the entry node). @@ -135,7 +136,8 @@ public: }; public: - DominatorTreeBase(bool isPostDom) : DominatorBase(isPostDom) {} + DominatorTreeBase(intptr_t ID, bool isPostDom) + : DominatorBase(ID, isPostDom) {} ~DominatorTreeBase() { reset(); } virtual void releaseMemory() { reset(); } @@ -206,7 +208,8 @@ public: /// class DominatorTree : public DominatorTreeBase { public: - DominatorTree() : DominatorTreeBase(false) {} + static const int ID; // Pass ID, replacement for typeid + DominatorTree() : DominatorTreeBase((intptr_t)&ID, false) {} BasicBlock *getRoot() const { assert(Roots.size() == 1 && "Should always have entry node!"); @@ -264,8 +267,9 @@ template <> struct GraphTraits /// class ETForestBase : public DominatorBase { public: - ETForestBase(bool isPostDom) : DominatorBase(isPostDom), Nodes(), - DFSInfoValid(false), SlowQueries(0) {} + ETForestBase(intptr_t ID, bool isPostDom) + : DominatorBase(ID, isPostDom), Nodes(), + DFSInfoValid(false), SlowQueries(0) {} virtual void releaseMemory() { reset(); } @@ -395,7 +399,9 @@ protected: class ETForest : public ETForestBase { public: - ETForest() : ETForestBase(false) {} + static const int ID; // Pass identifcation, replacement for typeid + + ETForest() : ETForestBase((intptr_t)&ID, false) {} BasicBlock *getRoot() const { assert(Roots.size() == 1 && "Should always have entry node!"); @@ -425,7 +431,8 @@ public: protected: DomSetMapType Frontiers; public: - DominanceFrontierBase(bool isPostDom) : DominatorBase(isPostDom) {} + DominanceFrontierBase(intptr_t ID, bool isPostDom) + : DominatorBase(ID, isPostDom) {} virtual void releaseMemory() { Frontiers.clear(); } @@ -470,7 +477,9 @@ public: /// class DominanceFrontier : public DominanceFrontierBase { public: - DominanceFrontier() : DominanceFrontierBase(false) {} + static const int ID; // Pass ID, replacement for typeid + DominanceFrontier() : + DominanceFrontierBase((intptr_t)& ID, false) {} BasicBlock *getRoot() const { assert(Roots.size() == 1 && "Should always have entry node!"); diff --git a/include/llvm/Analysis/FindUsedTypes.h b/include/llvm/Analysis/FindUsedTypes.h index 008e30c93ef..de892f1b9ca 100644 --- a/include/llvm/Analysis/FindUsedTypes.h +++ b/include/llvm/Analysis/FindUsedTypes.h @@ -24,6 +24,9 @@ class Type; class FindUsedTypes : public ModulePass { std::set UsedTypes; public: + static const int ID; // Pass identifcation, replacement for typeid + FindUsedTypes() : ModulePass((intptr_t)&ID) {} + /// getTypes - After the pass has been run, return the set containing all of /// the types used in the module. /// diff --git a/include/llvm/Analysis/IntervalPartition.h b/include/llvm/Analysis/IntervalPartition.h index bd998e81de2..07f054b1310 100644 --- a/include/llvm/Analysis/IntervalPartition.h +++ b/include/llvm/Analysis/IntervalPartition.h @@ -45,7 +45,9 @@ class IntervalPartition : public FunctionPass { std::vector Intervals; public: - IntervalPartition() : RootInterval(0) {} + static const int ID; // Pass identifcation, replacement for typeid + + IntervalPartition() : FunctionPass((intptr_t)&ID), RootInterval(0) {} // run - Calculate the interval partition for this function virtual bool runOnFunction(Function &F); diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h index 62f19e3c29e..8e38c07a477 100644 --- a/include/llvm/Analysis/LoopInfo.h +++ b/include/llvm/Analysis/LoopInfo.h @@ -241,6 +241,9 @@ class LoopInfo : public FunctionPass { std::vector TopLevelLoops; friend class Loop; public: + static const int ID; // Pass identifcation, replacement for typeid + + LoopInfo() : FunctionPass((intptr_t)&ID) {} ~LoopInfo() { releaseMemory(); } /// iterator/begin/end - The interface to the top-level loops in the current diff --git a/include/llvm/Analysis/LoopPass.h b/include/llvm/Analysis/LoopPass.h index 4163a09d333..24e61435ff8 100644 --- a/include/llvm/Analysis/LoopPass.h +++ b/include/llvm/Analysis/LoopPass.h @@ -29,6 +29,8 @@ class Function; class LoopPass : public Pass { public: + LoopPass(intptr_t pid) : Pass(pid) {} + // runOnLoop - THis method should be implemented by the subclass to perform // whatever action is necessary for the specfied Loop. virtual bool runOnLoop (Loop *L, LPPassManager &LPM) = 0; @@ -66,6 +68,7 @@ class LoopPass : public Pass { class LPPassManager : public FunctionPass, public PMDataManager { public: + static const int ID; LPPassManager(int Depth); /// run - Execute all of the passes scheduled for execution. Keep track of diff --git a/include/llvm/Analysis/PostDominators.h b/include/llvm/Analysis/PostDominators.h index 359f19daf88..793c7f48892 100644 --- a/include/llvm/Analysis/PostDominators.h +++ b/include/llvm/Analysis/PostDominators.h @@ -22,7 +22,10 @@ namespace llvm { /// compute the a post-dominator tree. /// struct PostDominatorTree : public DominatorTreeBase { - PostDominatorTree() : DominatorTreeBase(true) {} + static const int ID; // Pass identifcation, replacement for typeid + + PostDominatorTree() : + DominatorTreeBase((intptr_t)&ID, true) {} virtual bool runOnFunction(Function &F) { reset(); // Reset from the last time we were run... @@ -51,7 +54,8 @@ private: /// PostETForest Class - Concrete subclass of ETForestBase that is used to /// compute a forwards post-dominator ET-Forest. struct PostETForest : public ETForestBase { - PostETForest() : ETForestBase(true) {} + static const int ID; + PostETForest() : ETForestBase((intptr_t)&ID, true) {} virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); @@ -75,7 +79,9 @@ struct PostETForest : public ETForestBase { /// used to compute the a post-dominance frontier. /// struct PostDominanceFrontier : public DominanceFrontierBase { - PostDominanceFrontier() : DominanceFrontierBase(true) {} + static const int ID; + PostDominanceFrontier() + : DominanceFrontierBase((intptr_t) &ID, true) {} virtual bool runOnFunction(Function &) { Frontiers.clear(); diff --git a/include/llvm/Analysis/ProfileInfo.h b/include/llvm/Analysis/ProfileInfo.h index 88b2ea1c8c6..dc17ac1664d 100644 --- a/include/llvm/Analysis/ProfileInfo.h +++ b/include/llvm/Analysis/ProfileInfo.h @@ -38,6 +38,7 @@ namespace llvm { // entered. std::map, unsigned> EdgeCounts; public: + static const int ID; // Class identification, replacement for typeinfo virtual ~ProfileInfo(); // We want to be subclassed //===------------------------------------------------------------------===// diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h index 27d7e04a3e2..6b05714358d 100644 --- a/include/llvm/Analysis/ScalarEvolution.h +++ b/include/llvm/Analysis/ScalarEvolution.h @@ -197,7 +197,8 @@ namespace llvm { class ScalarEvolution : public FunctionPass { void *Impl; // ScalarEvolution uses the pimpl pattern public: - ScalarEvolution() : Impl(0) {} + static const int ID; // Pass identifcation, replacement for typeid + ScalarEvolution() : FunctionPass((intptr_t)&ID), Impl(0) {} /// getSCEV - Return a SCEV expression handle for the full generality of the /// specified expression. diff --git a/include/llvm/Analysis/ValueNumbering.h b/include/llvm/Analysis/ValueNumbering.h index f708f48382b..9d1aeb564dc 100644 --- a/include/llvm/Analysis/ValueNumbering.h +++ b/include/llvm/Analysis/ValueNumbering.h @@ -29,6 +29,7 @@ class Value; class Instruction; struct ValueNumbering { + static const int ID; // Class identification, replacement for typeinfo virtual ~ValueNumbering(); // We want to be subclassed /// getEqualNumberNodes - Return nodes with the same value number as the diff --git a/include/llvm/Assembly/PrintModulePass.h b/include/llvm/Assembly/PrintModulePass.h index cc9bca92882..4da55484eee 100644 --- a/include/llvm/Assembly/PrintModulePass.h +++ b/include/llvm/Assembly/PrintModulePass.h @@ -28,9 +28,10 @@ class PrintModulePass : public ModulePass { OStream *Out; // ostream to print on bool DeleteStream; // Delete the ostream in our dtor? public: - PrintModulePass() : Out(&cerr), DeleteStream(false) {} + static const int ID; + PrintModulePass() : ModulePass((intptr_t)&ID), Out(&cerr), DeleteStream(false) {} PrintModulePass(OStream *o, bool DS = false) - : Out(o), DeleteStream(DS) {} + : ModulePass((intptr_t)&ID), Out(o), DeleteStream(DS) {} ~PrintModulePass() { if (DeleteStream) delete Out; @@ -51,10 +52,12 @@ class PrintFunctionPass : public FunctionPass { OStream *Out; // ostream to print on bool DeleteStream; // Delete the ostream in our dtor? public: - PrintFunctionPass() : Banner(""), Out(&cerr), DeleteStream(false) {} + static const int ID; + PrintFunctionPass() : FunctionPass((intptr_t)&ID), Banner(""), Out(&cerr), + DeleteStream(false) {} PrintFunctionPass(const std::string &B, OStream *o = &cout, bool DS = false) - : Banner(B), Out(o), DeleteStream(DS) {} + : FunctionPass((intptr_t)&ID), Banner(B), Out(o), DeleteStream(DS) {} inline ~PrintFunctionPass() { if (DeleteStream) delete Out; diff --git a/include/llvm/Bytecode/WriteBytecodePass.h b/include/llvm/Bytecode/WriteBytecodePass.h index b0155e4ddf6..5c21ccded5d 100644 --- a/include/llvm/Bytecode/WriteBytecodePass.h +++ b/include/llvm/Bytecode/WriteBytecodePass.h @@ -26,10 +26,12 @@ class WriteBytecodePass : public ModulePass { bool DeleteStream; bool CompressFile; public: + static const int ID; // Pass identifcation, replacement for typeid WriteBytecodePass() - : Out(&cout), DeleteStream(false), CompressFile(false) {} + : ModulePass((intptr_t) &ID), Out(&cout), DeleteStream(false), + CompressFile(false) {} WriteBytecodePass(OStream *o, bool DS = false, bool CF = false) - : Out(o), DeleteStream(DS), CompressFile(CF) {} + : ModulePass((intptr_t) &ID), Out(o), DeleteStream(DS), CompressFile(CF) {} inline ~WriteBytecodePass() { if (DeleteStream) delete Out; diff --git a/include/llvm/CallGraphSCCPass.h b/include/llvm/CallGraphSCCPass.h index af5cb849a38..90894c280c6 100644 --- a/include/llvm/CallGraphSCCPass.h +++ b/include/llvm/CallGraphSCCPass.h @@ -31,6 +31,8 @@ class PMStack; struct CallGraphSCCPass : public Pass { + CallGraphSCCPass(intptr_t pid) : Pass(pid) {} + /// doInitialization - This method is called before the SCC's of the program /// has been processed, allowing the pass to do initialization as necessary. virtual bool doInitialization(CallGraph &CG) { diff --git a/include/llvm/CodeGen/AsmPrinter.h b/include/llvm/CodeGen/AsmPrinter.h index 024001e9d66..3a5418d937b 100644 --- a/include/llvm/CodeGen/AsmPrinter.h +++ b/include/llvm/CodeGen/AsmPrinter.h @@ -34,6 +34,8 @@ namespace llvm { /// AsmPrinter - This class is intended to be used as a driving class for all /// asm writers. class AsmPrinter : public MachineFunctionPass { + static const int ID; + /// FunctionNumber - This provides a unique ID for each function emitted in /// this translation unit. It is autoincremented by SetupMachineFunction, /// and can be accessed with getFunctionNumber() and diff --git a/include/llvm/CodeGen/LiveIntervalAnalysis.h b/include/llvm/CodeGen/LiveIntervalAnalysis.h index a42471d6312..3ea0272425d 100644 --- a/include/llvm/CodeGen/LiveIntervalAnalysis.h +++ b/include/llvm/CodeGen/LiveIntervalAnalysis.h @@ -65,6 +65,9 @@ namespace llvm { BitVector JoinedLIs; public: + static const int ID; // Pass identifcation, replacement for typeid + LiveIntervals() : MachineFunctionPass((intptr_t)&ID) {} + struct CopyRec { MachineInstr *MI; unsigned SrcReg, DstReg; diff --git a/include/llvm/CodeGen/LiveVariables.h b/include/llvm/CodeGen/LiveVariables.h index ebbe610ed01..ce377cd2cfa 100644 --- a/include/llvm/CodeGen/LiveVariables.h +++ b/include/llvm/CodeGen/LiveVariables.h @@ -40,6 +40,9 @@ class MRegisterInfo; class LiveVariables : public MachineFunctionPass { public: + static const int ID; // Pass identifcation, replacement for typeid + LiveVariables() : MachineFunctionPass((intptr_t)&ID) {} + /// VarInfo - This represents the regions where a virtual register is live in /// the program. We represent this with three different pieces of /// information: the instruction that uniquely defines the value, the set of diff --git a/include/llvm/CodeGen/MachineFunctionPass.h b/include/llvm/CodeGen/MachineFunctionPass.h index 77af52a3474..7429e7b96c4 100644 --- a/include/llvm/CodeGen/MachineFunctionPass.h +++ b/include/llvm/CodeGen/MachineFunctionPass.h @@ -26,6 +26,8 @@ namespace llvm { struct MachineFunctionPass : public FunctionPass { + MachineFunctionPass(intptr_t ID) : FunctionPass(ID) {} + /// runOnMachineFunction - This method must be overloaded to perform the /// desired machine code transformation or analysis. /// diff --git a/include/llvm/CodeGen/MachineModuleInfo.h b/include/llvm/CodeGen/MachineModuleInfo.h index 28201dcfdc6..c23916def9c 100644 --- a/include/llvm/CodeGen/MachineModuleInfo.h +++ b/include/llvm/CodeGen/MachineModuleInfo.h @@ -1022,6 +1022,8 @@ private: std::vector TypeInfos; public: + static const int ID; // Pass identifcation, replacement for typeid + MachineModuleInfo(); ~MachineModuleInfo(); diff --git a/include/llvm/CodeGen/SelectionDAGISel.h b/include/llvm/CodeGen/SelectionDAGISel.h index 9d5b059759e..f363daf9e4c 100644 --- a/include/llvm/CodeGen/SelectionDAGISel.h +++ b/include/llvm/CodeGen/SelectionDAGISel.h @@ -41,8 +41,10 @@ public: MachineBasicBlock *BB; std::vector TopOrder; unsigned DAGSize; + static const int ID; - explicit SelectionDAGISel(TargetLowering &tli) : TLI(tli), DAGSize(0) {} + explicit SelectionDAGISel(TargetLowering &tli) : + FunctionPass((intptr_t)&ID), TLI(tli), DAGSize(0) {} TargetLowering &getTargetLowering() { return TLI; } diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h index 1ab6ff9a720..d678df6430b 100644 --- a/include/llvm/Pass.h +++ b/include/llvm/Pass.h @@ -34,8 +34,8 @@ #include #include #include -#include #include +#include namespace llvm { @@ -77,7 +77,7 @@ typedef enum PassManagerType PassManagerType; /// class Pass { AnalysisResolver *Resolver; // Used to resolve analysis - const PassInfo *PassInfoCache; + intptr_t PassID; // AnalysisImpls - This keeps track of which passes implement the interfaces // that are required by the current pass (to implement getAnalysis()). @@ -87,7 +87,7 @@ class Pass { void operator=(const Pass&); // DO NOT IMPLEMENT Pass(const Pass &); // DO NOT IMPLEMENT public: - Pass() : Resolver(0), PassInfoCache(0) {} + Pass(intptr_t pid) : Resolver(0), PassID(pid) {} virtual ~Pass(); /// getPassName - Return a nice clean name for a pass. This usually @@ -163,12 +163,12 @@ public: template static const PassInfo *getClassPassInfo() { - return lookupPassInfo(typeid(AnalysisClass)); + return lookupPassInfo((intptr_t)&AnalysisClass::ID); } // lookupPassInfo - Return the pass info object for the specified pass class, // or null if it is not known. - static const PassInfo *lookupPassInfo(const std::type_info &TI); + static const PassInfo *lookupPassInfo(intptr_t TI); /// getAnalysisToUpdate() - This function is used by subclasses /// to get to the analysis information that might be around that needs to be @@ -232,6 +232,7 @@ public: return PMT_ModulePassManager; } + ModulePass(intptr_t pid) : Pass(pid) {} // Force out-of-line virtual method. virtual ~ModulePass(); }; @@ -256,6 +257,7 @@ public: /// virtual bool runOnModule(Module &M) { return false; } + ImmutablePass(intptr_t pid) : ModulePass(pid) {} // Force out-of-line virtual method. virtual ~ImmutablePass(); }; @@ -271,6 +273,8 @@ public: /// class FunctionPass : public Pass { public: + FunctionPass(intptr_t pid) : Pass(pid) {} + /// doInitialization - Virtual method overridden by subclasses to do /// any necessary per-module initialization. /// @@ -320,6 +324,8 @@ public: /// class BasicBlockPass : public Pass { public: + BasicBlockPass(intptr_t pid) : Pass(pid) {} + /// doInitialization - Virtual method overridden by subclasses to do /// any necessary per-module initialization. /// diff --git a/include/llvm/PassManagers.h b/include/llvm/PassManagers.h index 29912b140d7..81e89a7ff5f 100644 --- a/include/llvm/PassManagers.h +++ b/include/llvm/PassManagers.h @@ -336,7 +336,9 @@ private: class FPPassManager : public ModulePass, public PMDataManager { public: - explicit FPPassManager(int Depth) : PMDataManager(Depth) { } + static const int ID; + explicit FPPassManager(int Depth) + : ModulePass((intptr_t)&ID), PMDataManager(Depth) { } /// run - Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the module, and if so, return true. diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h index 7c3c4a9d660..f594d45f152 100644 --- a/include/llvm/PassSupport.h +++ b/include/llvm/PassSupport.h @@ -37,19 +37,19 @@ class TargetMachine; class PassInfo { const char *PassName; // Nice name for Pass const char *PassArgument; // Command Line argument to run this pass - const std::type_info &TypeInfo; // type_info object for this Pass class + intptr_t PassID; bool IsCFGOnlyPass; // Pass only looks at the CFG. bool IsAnalysisGroup; // True if an analysis group. std::vector ItfImpl;// Interfaces implemented by this pass - Pass *(*NormalCtor)(); // No argument ctor + Pass *(*NormalCtor)(); public: /// PassInfo ctor - Do not call this directly, this should only be invoked /// through RegisterPass. - PassInfo(const char *name, const char *arg, const std::type_info &ti, + PassInfo(const char *name, const char *arg, intptr_t pi, Pass *(*normal)() = 0, bool isCFGOnly = false) - : PassName(name), PassArgument(arg), TypeInfo(ti), + : PassName(name), PassArgument(arg), PassID(pi), IsCFGOnlyPass(isCFGOnly), IsAnalysisGroup(false), NormalCtor(normal) { } @@ -65,8 +65,8 @@ public: const char *getPassArgument() const { return PassArgument; } /// getTypeInfo - Return the type_info object for the pass... - /// - const std::type_info &getTypeInfo() const { return TypeInfo; } + /// TODO : Rename + intptr_t getTypeInfo() const { return PassID; } /// isAnalysisGroup - Return true if this is an analysis group, not a normal /// pass. @@ -139,12 +139,12 @@ struct RegisterPassBase { typedef Pass* (*NormalCtor_t)(); - RegisterPassBase(const char *Name, const char *Arg, const std::type_info &TI, + RegisterPassBase(const char *Name, const char *Arg, intptr_t TI, NormalCtor_t NormalCtor = 0, bool CFGOnly = false) : PIObj(Name, Arg, TI, NormalCtor, CFGOnly) { registerPass(); } - RegisterPassBase(const std::type_info &TI) + RegisterPassBase(intptr_t TI) : PIObj("", "", TI) { // This ctor may only be used for analysis groups: it does not auto-register // the pass. @@ -165,7 +165,7 @@ struct RegisterPass : public RegisterPassBase { // Register Pass using default constructor... RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false) - : RegisterPassBase(Name, PassArg, typeid(PassName), + : RegisterPassBase(Name, PassArg, (intptr_t)&PassName::ID, (RegisterPassBase::NormalCtor_t)callDefaultCtor, CFGOnly) { } }; @@ -195,8 +195,8 @@ class RegisterAGBase : public RegisterPassBase { const PassInfo *ImplementationInfo; bool isDefaultImplementation; protected: - explicit RegisterAGBase(const std::type_info &Interface, - const std::type_info *Pass = 0, + explicit RegisterAGBase(intptr_t InterfaceID, + intptr_t PassID = 0, bool isDefault = false); void setGroupName(const char *Name); }; @@ -204,12 +204,12 @@ protected: template struct RegisterAnalysisGroup : public RegisterAGBase { explicit RegisterAnalysisGroup(RegisterPassBase &RPB) - : RegisterAGBase(typeid(Interface), &RPB.getPassInfo()->getTypeInfo(), + : RegisterAGBase((intptr_t) &Interface::ID, RPB.getPassInfo()->getTypeInfo(), Default) { } explicit RegisterAnalysisGroup(const char *Name) - : RegisterAGBase(typeid(Interface)) { + : RegisterAGBase((intptr_t) &Interface::ID) { setGroupName(Name); } }; diff --git a/include/llvm/Target/TargetData.h b/include/llvm/Target/TargetData.h index 4e330e862db..bfc41b1640c 100644 --- a/include/llvm/Target/TargetData.h +++ b/include/llvm/Target/TargetData.h @@ -108,14 +108,15 @@ public: /// /// @note This has to exist, because this is a pass, but it should never be /// used. - TargetData() { + TargetData() : ImmutablePass((intptr_t)&ID) { assert(0 && "ERROR: Bad TargetData ctor used. " "Tool did not specify a TargetData to use?"); abort(); } /// Constructs a TargetData from a specification string. See init(). - TargetData(const std::string &TargetDescription) { + TargetData(const std::string &TargetDescription) + : ImmutablePass((intptr_t)&ID) { init(TargetDescription); } @@ -123,7 +124,7 @@ public: TargetData(const Module *M); TargetData(const TargetData &TD) : - ImmutablePass(), + ImmutablePass((intptr_t)&ID), LittleEndian(TD.isLittleEndian()), PointerMemSize(TD.PointerMemSize), PointerABIAlign(TD.PointerABIAlign), @@ -200,6 +201,8 @@ public: /// specified global, returned in log form. This includes an explicitly /// requested alignment (if the global has one). unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const; + + static const int ID; // Pass identifcation, replacement for typeid }; /// StructLayout - used to lazily calculate structure layout information for a diff --git a/include/llvm/Transforms/RSProfiling.h b/include/llvm/Transforms/RSProfiling.h index 2df2932f295..900d147f7d6 100644 --- a/include/llvm/Transforms/RSProfiling.h +++ b/include/llvm/Transforms/RSProfiling.h @@ -23,6 +23,9 @@ namespace llvm { /// this interface are expected to chain to other implementations, such that /// multiple profilers can be support simultaniously. struct RSProfilers : public ModulePass { + static const int ID; // Pass identification, replacement for typeinfo + RSProfilers() : ModulePass((intptr_t)&ID) {} + /// isProfiling - This method returns true if the value passed it was /// inserted by the profiler. virtual bool isProfiling(Value* v) = 0; diff --git a/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h b/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h index 526851ba448..c120acce6bf 100644 --- a/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h +++ b/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h @@ -25,7 +25,9 @@ namespace llvm { struct UnifyFunctionExitNodes : public FunctionPass { BasicBlock *ReturnBlock, *UnwindBlock, *UnreachableBlock; public: - UnifyFunctionExitNodes() : ReturnBlock(0), UnwindBlock(0) {} + static const int ID; // Pass identifcation, replacement for typeid + UnifyFunctionExitNodes() : FunctionPass((intptr_t)&ID), + ReturnBlock(0), UnwindBlock(0) {} // We can preserve non-critical-edgeness when we unify function exit nodes virtual void getAnalysisUsage(AnalysisUsage &AU) const; diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp index c7b68fab686..7499db562b7 100644 --- a/lib/Analysis/AliasAnalysis.cpp +++ b/lib/Analysis/AliasAnalysis.cpp @@ -34,6 +34,7 @@ using namespace llvm; // Register the AliasAnalysis interface, providing a nice name to refer to. namespace { + const int AliasAnalysis::ID = 0; RegisterAnalysisGroup Z("Alias Analysis"); } diff --git a/lib/Analysis/AliasAnalysisCounter.cpp b/lib/Analysis/AliasAnalysisCounter.cpp index fcd5edc768b..ee1980fc4c0 100644 --- a/lib/Analysis/AliasAnalysisCounter.cpp +++ b/lib/Analysis/AliasAnalysisCounter.cpp @@ -34,7 +34,8 @@ namespace { const char *Name; Module *M; public: - AliasAnalysisCounter() { + static const int ID; // Class identification, replacement for typeinfo + AliasAnalysisCounter() : ModulePass((intptr_t) &ID) { No = May = Must = 0; NoMR = JustRef = JustMod = MR = 0; } @@ -107,6 +108,7 @@ namespace { } }; + const int AliasAnalysisCounter::ID = 0; RegisterPass X("count-aa", "Count Alias Analysis Query Responses"); RegisterAnalysisGroup Y(X); diff --git a/lib/Analysis/AliasAnalysisEvaluator.cpp b/lib/Analysis/AliasAnalysisEvaluator.cpp index 73ea423c45f..f2631cb8ba6 100644 --- a/lib/Analysis/AliasAnalysisEvaluator.cpp +++ b/lib/Analysis/AliasAnalysisEvaluator.cpp @@ -50,6 +50,9 @@ namespace { unsigned NoModRef, Mod, Ref, ModRef; public: + static const int ID; // Pass identifcation, replacement for typeid + AAEval() : FunctionPass((intptr_t)&ID) {} + virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); AU.setPreservesAll(); @@ -70,6 +73,7 @@ namespace { bool doFinalization(Module &M); }; + const int AAEval::ID = 0; RegisterPass X("aa-eval", "Exhaustive Alias Analysis Precision Evaluator"); } diff --git a/lib/Analysis/AliasDebugger.cpp b/lib/Analysis/AliasDebugger.cpp index 3f7f1cccae0..a4df97a196f 100644 --- a/lib/Analysis/AliasDebugger.cpp +++ b/lib/Analysis/AliasDebugger.cpp @@ -40,6 +40,9 @@ namespace { std::set Vals; public: + static const int ID; // Class identification, replacement for typeinfo + AliasDebugger() : ModulePass((intptr_t)&ID) {} + bool runOnModule(Module &M) { InitializeAliasAnalysis(this); // set up super class @@ -119,6 +122,7 @@ namespace { }; + const int AliasDebugger::ID = 0; RegisterPass X("debug-aa", "AA use debugger"); RegisterAnalysisGroup Y(X); } diff --git a/lib/Analysis/AliasSetTracker.cpp b/lib/Analysis/AliasSetTracker.cpp index 9564326685b..90c90fe58f5 100644 --- a/lib/Analysis/AliasSetTracker.cpp +++ b/lib/Analysis/AliasSetTracker.cpp @@ -555,6 +555,9 @@ namespace { class VISIBILITY_HIDDEN AliasSetPrinter : public FunctionPass { AliasSetTracker *Tracker; public: + static const int ID; // Pass identifcation, replacement for typeid + AliasSetPrinter() : FunctionPass((intptr_t)&ID) {} + virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); AU.addRequired(); @@ -570,5 +573,6 @@ namespace { return false; } }; + const int AliasSetPrinter::ID = 0; RegisterPass X("print-alias-sets", "Alias Set Printer"); } diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp index 1ca1a35b9f5..b1369a29206 100644 --- a/lib/Analysis/BasicAliasAnalysis.cpp +++ b/lib/Analysis/BasicAliasAnalysis.cpp @@ -36,6 +36,9 @@ namespace { /// such it doesn't follow many of the rules that other alias analyses must. /// struct VISIBILITY_HIDDEN NoAA : public ImmutablePass, public AliasAnalysis { + static const int ID; // Class identification, replacement for typeinfo + NoAA() : ImmutablePass((intptr_t)&ID) {} + virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); } @@ -74,6 +77,7 @@ namespace { }; // Register this pass... + const int NoAA::ID = 0; RegisterPass U("no-aa", "No Alias Analysis (always returns 'may' alias)"); @@ -88,6 +92,7 @@ namespace { /// Because it doesn't chain to a previous alias analysis (like -no-aa), it /// derives from the NoAA class. struct VISIBILITY_HIDDEN BasicAliasAnalysis : public NoAA { + static const int ID; // Class identification, replacement for typeinfo AliasResult alias(const Value *V1, unsigned V1Size, const Value *V2, unsigned V2Size); @@ -119,6 +124,7 @@ namespace { }; // Register this pass... + const int BasicAliasAnalysis::ID = 0; RegisterPass X("basicaa", "Basic Alias Analysis (default AA impl)"); diff --git a/lib/Analysis/CFGPrinter.cpp b/lib/Analysis/CFGPrinter.cpp index a57a0685a7e..61544603758 100644 --- a/lib/Analysis/CFGPrinter.cpp +++ b/lib/Analysis/CFGPrinter.cpp @@ -91,6 +91,9 @@ struct DOTGraphTraits : public DefaultDOTGraphTraits { namespace { struct VISIBILITY_HIDDEN CFGPrinter : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + CFGPrinter() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F) { std::string Filename = "cfg." + F.getName() + ".dot"; cerr << "Writing '" << Filename << "'..."; @@ -111,10 +114,12 @@ namespace { } }; + const int CFGPrinter::ID = 0; RegisterPass P1("print-cfg", "Print CFG of function to 'dot' file"); struct VISIBILITY_HIDDEN CFGOnlyPrinter : public CFGPrinter { + static const int ID; // Pass identifcation, replacement for typeid virtual bool runOnFunction(Function &F) { bool OldCFGOnly = CFGOnly; CFGOnly = true; @@ -129,6 +134,7 @@ namespace { } }; + const int CFGOnlyPrinter::ID = 0; RegisterPass P2("print-cfg-only", "Print CFG of function to 'dot' file (with no function bodies)"); diff --git a/lib/Analysis/IPA/Andersens.cpp b/lib/Analysis/IPA/Andersens.cpp index 0a281c89458..cd90a6f22b0 100644 --- a/lib/Analysis/IPA/Andersens.cpp +++ b/lib/Analysis/IPA/Andersens.cpp @@ -75,12 +75,17 @@ STATISTIC(NumIndirectCallees , "Number of indirect callees found"); namespace { class VISIBILITY_HIDDEN Andersens : public ModulePass, public AliasAnalysis, private InstVisitor { + public: + static const int ID; // Class identification, replacement for typeinfo + Andersens() : ModulePass((intptr_t)&ID) {} + private: /// Node class - This class is used to represent a memory object in the /// program, and is the primitive used to build the points-to graph. class Node { std::vector Pointees; Value *Val; public: + static const unsigned ID; // Pass identifcation, replacement for typeid Node() : Val(0) {} Node *setValue(Value *V) { assert(Val == 0 && "Value already set for this node!"); @@ -334,6 +339,7 @@ namespace { void visitInstruction(Instruction &I); }; + const int Andersens::ID = 0; RegisterPass X("anders-aa", "Andersen's Interprocedural Alias Analysis"); RegisterAnalysisGroup Y(X); diff --git a/lib/Analysis/IPA/CallGraph.cpp b/lib/Analysis/IPA/CallGraph.cpp index bb96bb2d654..43e70bb2184 100644 --- a/lib/Analysis/IPA/CallGraph.cpp +++ b/lib/Analysis/IPA/CallGraph.cpp @@ -51,7 +51,9 @@ class VISIBILITY_HIDDEN BasicCallGraph : public CallGraph, public ModulePass { CallGraphNode *CallsExternalNode; public: - BasicCallGraph() : Root(0), ExternalCallingNode(0), CallsExternalNode(0) {} + static const int ID; // Class identification, replacement for typeinfo + BasicCallGraph() : ModulePass((intptr_t)&ID), Root(0), + ExternalCallingNode(0), CallsExternalNode(0) {} // runOnModule - Compute the call graph for the specified module. virtual bool runOnModule(Module &M) { @@ -188,7 +190,9 @@ private: } }; +const int CallGraph::ID = 0; RegisterAnalysisGroup X("Call Graph"); +const int BasicCallGraph::ID = 0; RegisterPass Y("basiccg", "Basic CallGraph Construction"); RegisterAnalysisGroup Z(Y); diff --git a/lib/Analysis/IPA/CallGraphSCCPass.cpp b/lib/Analysis/IPA/CallGraphSCCPass.cpp index 0640b63e6b6..2c5aeaa4c2a 100644 --- a/lib/Analysis/IPA/CallGraphSCCPass.cpp +++ b/lib/Analysis/IPA/CallGraphSCCPass.cpp @@ -30,7 +30,9 @@ using namespace llvm; class CGPassManager : public ModulePass, public PMDataManager { public: - CGPassManager(int Depth) : PMDataManager(Depth) { } + static const int ID; + CGPassManager(int Depth) + : ModulePass((intptr_t)&ID), PMDataManager(Depth) { } /// run - Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the module, and if so, return true. @@ -71,6 +73,7 @@ public: } }; +const int CGPassManager::ID = 0; /// run - Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the module, and if so, return true. bool CGPassManager::runOnModule(Module &M) { diff --git a/lib/Analysis/IPA/FindUsedTypes.cpp b/lib/Analysis/IPA/FindUsedTypes.cpp index 1208dd1ccca..d35f7beed1c 100644 --- a/lib/Analysis/IPA/FindUsedTypes.cpp +++ b/lib/Analysis/IPA/FindUsedTypes.cpp @@ -21,6 +21,7 @@ #include "llvm/Support/InstIterator.h" using namespace llvm; +const int FindUsedTypes::ID = 0; static RegisterPass X("printusedtypes", "Find Used Types"); diff --git a/lib/Analysis/IPA/GlobalsModRef.cpp b/lib/Analysis/IPA/GlobalsModRef.cpp index 8d41751b88d..ea8b1d84871 100644 --- a/lib/Analysis/IPA/GlobalsModRef.cpp +++ b/lib/Analysis/IPA/GlobalsModRef.cpp @@ -83,6 +83,9 @@ namespace { std::map FunctionInfo; public: + static const int ID; + GlobalsModRef() : ModulePass((intptr_t)&ID) {} + bool runOnModule(Module &M) { InitializeAliasAnalysis(this); // set up super class AnalyzeGlobals(M); // find non-addr taken globals @@ -143,6 +146,7 @@ namespace { bool AnalyzeIndirectGlobalMemory(GlobalValue *GV); }; + const int GlobalsModRef::ID = 0; RegisterPass X("globalsmodref-aa", "Simple mod/ref analysis for globals"); RegisterAnalysisGroup Y(X); diff --git a/lib/Analysis/InstCount.cpp b/lib/Analysis/InstCount.cpp index e075fee9f6a..23c891b5ed8 100644 --- a/lib/Analysis/InstCount.cpp +++ b/lib/Analysis/InstCount.cpp @@ -51,6 +51,9 @@ namespace { abort(); } public: + static const int ID; // Pass identifcation, replacement for typeid + InstCount() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -60,6 +63,7 @@ namespace { }; + const int InstCount::ID = 0; RegisterPass X("instcount", "Counts the various types of Instructions"); } diff --git a/lib/Analysis/IntervalPartition.cpp b/lib/Analysis/IntervalPartition.cpp index 2385a7d2470..b380a5190d5 100644 --- a/lib/Analysis/IntervalPartition.cpp +++ b/lib/Analysis/IntervalPartition.cpp @@ -15,6 +15,7 @@ #include "llvm/Analysis/IntervalIterator.h" using namespace llvm; +const int IntervalPartition::ID = 0; static RegisterPass X("intervals", "Interval Partition Construction", true); @@ -88,7 +89,8 @@ bool IntervalPartition::runOnFunction(Function &F) { // existing interval graph. This takes an additional boolean parameter to // distinguish it from a copy constructor. Always pass in false for now. // -IntervalPartition::IntervalPartition(IntervalPartition &IP, bool) { +IntervalPartition::IntervalPartition(IntervalPartition &IP, bool) + : FunctionPass((intptr_t) &ID) { Interval *FunctionStart = IP.getRootInterval(); assert(FunctionStart && "Cannot operate on empty IntervalPartitions!"); diff --git a/lib/Analysis/LoadValueNumbering.cpp b/lib/Analysis/LoadValueNumbering.cpp index 16687b04194..fdb5545c2bb 100644 --- a/lib/Analysis/LoadValueNumbering.cpp +++ b/lib/Analysis/LoadValueNumbering.cpp @@ -40,6 +40,8 @@ using namespace llvm; namespace { // FIXME: This should not be a FunctionPass. struct VISIBILITY_HIDDEN LoadVN : public FunctionPass, public ValueNumbering { + static const int ID; // Class identification, replacement for typeinfo + LoadVN() : FunctionPass((intptr_t)&ID) {} /// Pass Implementation stuff. This doesn't do any analysis. /// @@ -81,6 +83,7 @@ namespace { std::vector &RetVals) const; }; + const int LoadVN::ID = 0; // Register this pass... RegisterPass X("load-vn", "Load Value Numbering"); diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp index ab71b883a11..fd66d295840 100644 --- a/lib/Analysis/LoopInfo.cpp +++ b/lib/Analysis/LoopInfo.cpp @@ -27,6 +27,7 @@ #include using namespace llvm; +const int LoopInfo::ID = 0; static RegisterPass X("loops", "Natural Loop Construction", true); diff --git a/lib/Analysis/LoopPass.cpp b/lib/Analysis/LoopPass.cpp index fc431035c07..eeb27ac1b36 100644 --- a/lib/Analysis/LoopPass.cpp +++ b/lib/Analysis/LoopPass.cpp @@ -20,9 +20,12 @@ using namespace llvm; //===----------------------------------------------------------------------===// // LPPassManager // + +const int LPPassManager::ID = 0; /// LPPassManager manages FPPassManagers and CalLGraphSCCPasses. -LPPassManager::LPPassManager(int Depth) : PMDataManager(Depth) { +LPPassManager::LPPassManager(int Depth) + : FunctionPass((intptr_t)&ID), PMDataManager(Depth) { skipThisLoop = false; redoThisLoop = false; LI = NULL; diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp index add25fdf42f..a328a89414d 100644 --- a/lib/Analysis/PostDominators.cpp +++ b/lib/Analysis/PostDominators.cpp @@ -22,6 +22,9 @@ using namespace llvm; // PostDominatorTree Implementation //===----------------------------------------------------------------------===// +const int PostDominatorTree::ID = 0; +const int PostDominanceFrontier::ID = 0; +const int PostETForest::ID = 0; static RegisterPass F("postdomtree", "Post-Dominator Tree Construction", true); diff --git a/lib/Analysis/ProfileInfo.cpp b/lib/Analysis/ProfileInfo.cpp index 6eead0fd6ec..27da8162080 100644 --- a/lib/Analysis/ProfileInfo.cpp +++ b/lib/Analysis/ProfileInfo.cpp @@ -22,6 +22,7 @@ using namespace llvm; // Register the ProfileInfo interface, providing a nice name to refer to. namespace { + const int ProfileInfo::ID = 0; RegisterAnalysisGroup Z("Profile Information"); } @@ -84,8 +85,12 @@ unsigned ProfileInfo::getExecutionCount(BasicBlock *BB) const { namespace { struct VISIBILITY_HIDDEN NoProfileInfo - : public ImmutablePass, public ProfileInfo {}; + : public ImmutablePass, public ProfileInfo { + static const int ID; // Class identification, replacement for typeinfo + NoProfileInfo() : ImmutablePass((intptr_t)&ID) {} + }; + const int NoProfileInfo::ID = 0; // Register this pass... RegisterPass X("no-profile", "No Profile Information"); diff --git a/lib/Analysis/ProfileInfoLoaderPass.cpp b/lib/Analysis/ProfileInfoLoaderPass.cpp index 9a597a27e4c..9697de8cdde 100644 --- a/lib/Analysis/ProfileInfoLoaderPass.cpp +++ b/lib/Analysis/ProfileInfoLoaderPass.cpp @@ -32,8 +32,9 @@ namespace { class VISIBILITY_HIDDEN LoaderPass : public ModulePass, public ProfileInfo { std::string Filename; public: + static const int ID; // Class identification, replacement for typeinfo LoaderPass(const std::string &filename = "") - : Filename(filename) { + : ModulePass((intptr_t)&ID), Filename(filename) { if (filename.empty()) Filename = ProfileInfoFilename; } @@ -49,6 +50,7 @@ namespace { virtual bool runOnModule(Module &M); }; + const int LoaderPass::ID = 0; RegisterPass X("profile-loader", "Load profile information from llvmprof.out"); diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index 473eadcd878..5dae7f0bf1c 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -102,6 +102,7 @@ MaxBruteForceIterations("scalar-evolution-max-iterations", cl::ReallyHidden, cl::init(100)); namespace { + const int ScalarEvolution::ID = 0; RegisterPass R("scalar-evolution", "Scalar Evolution Analysis"); } diff --git a/lib/Analysis/ValueNumbering.cpp b/lib/Analysis/ValueNumbering.cpp index 963ccb90f3e..2ecbce55c20 100644 --- a/lib/Analysis/ValueNumbering.cpp +++ b/lib/Analysis/ValueNumbering.cpp @@ -22,6 +22,7 @@ #include "llvm/Support/Compiler.h" using namespace llvm; +const int ValueNumbering::ID = 0; // Register the ValueNumbering interface, providing a nice name to refer to. static RegisterAnalysisGroup X("Value Numbering"); @@ -51,6 +52,9 @@ namespace { /// struct VISIBILITY_HIDDEN BasicVN : public ImmutablePass, public ValueNumbering { + static const int ID; // Class identification, replacement for typeinfo + BasicVN() : ImmutablePass((intptr_t)&ID) {} + /// getEqualNumberNodes - Return nodes with the same value number as the /// specified Value. This fills in the argument vector with any equal /// values. @@ -61,6 +65,7 @@ namespace { std::vector &RetVals) const; }; + const int BasicVN::ID = 0; // Register this pass... RegisterPass X("basicvn", "Basic Value Numbering (default GVN impl)"); diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp index b4a26916008..3e09a92e9fa 100644 --- a/lib/Bytecode/Writer/Writer.cpp +++ b/lib/Bytecode/Writer/Writer.cpp @@ -47,6 +47,7 @@ using namespace llvm; /// @brief The bytecode version number const unsigned BCVersionNum = 7; +const int WriteBytecodePass::ID = 0; static RegisterPass X("emitbytecode", "Bytecode Writer"); STATISTIC(BytesWritten, "Number of bytecode bytes written"); diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp index aa71ee0b6db..4ce379c3e4b 100644 --- a/lib/CodeGen/AsmPrinter.cpp +++ b/lib/CodeGen/AsmPrinter.cpp @@ -32,9 +32,10 @@ using namespace llvm; static cl::opt AsmVerbose("asm-verbose", cl::Hidden, cl::desc("Add comments to directives.")); +const int AsmPrinter::ID = 0; AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm, const TargetAsmInfo *T) -: FunctionNumber(0), O(o), TM(tm), TAI(T) + : MachineFunctionPass((intptr_t)&ID), FunctionNumber(0), O(o), TM(tm), TAI(T) {} std::string AsmPrinter::getSectionForFunction(const Function &F) const { diff --git a/lib/CodeGen/BranchFolding.cpp b/lib/CodeGen/BranchFolding.cpp index 33f96df302f..394fe7b81b1 100644 --- a/lib/CodeGen/BranchFolding.cpp +++ b/lib/CodeGen/BranchFolding.cpp @@ -39,6 +39,9 @@ static cl::opt EnableTailMerge("enable-tail-merge", cl::Hidden); namespace { struct BranchFolder : public MachineFunctionPass { + static const int ID; + BranchFolder() : MachineFunctionPass((intptr_t)&ID) {} + virtual bool runOnMachineFunction(MachineFunction &MF); virtual const char *getPassName() const { return "Control Flow Optimizer"; } const TargetInstrInfo *TII; @@ -64,6 +67,7 @@ namespace { MachineBasicBlock *TBB, MachineBasicBlock *FBB, const std::vector &Cond); }; + const int BranchFolder::ID = 0; } FunctionPass *llvm::createBranchFoldingPass() { return new BranchFolder(); } diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp index ffc0a929f31..ce534092ba3 100644 --- a/lib/CodeGen/ELFWriter.cpp +++ b/lib/CodeGen/ELFWriter.cpp @@ -47,6 +47,7 @@ #include using namespace llvm; +const int ELFWriter::ID = 0; /// AddELFWriter - Concrete function to add the ELF writer to the function pass /// manager. MachineCodeEmitter *llvm::AddELFWriter(FunctionPassManager &FPM, @@ -176,7 +177,8 @@ bool ELFCodeEmitter::finishFunction(MachineFunction &F) { // ELFWriter Implementation //===----------------------------------------------------------------------===// -ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) { +ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) { e_flags = 0; // e_flags defaults to 0, no flags. is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64; diff --git a/lib/CodeGen/ELFWriter.h b/lib/CodeGen/ELFWriter.h index e64a9c946b6..8b577a0a783 100644 --- a/lib/CodeGen/ELFWriter.h +++ b/lib/CodeGen/ELFWriter.h @@ -30,6 +30,8 @@ namespace llvm { class ELFWriter : public MachineFunctionPass { friend class ELFCodeEmitter; public: + static const int ID; + MachineCodeEmitter &getMachineCodeEmitter() const { return *(MachineCodeEmitter*)MCE; } diff --git a/lib/CodeGen/LiveIntervalAnalysis.cpp b/lib/CodeGen/LiveIntervalAnalysis.cpp index c542033548d..cc6c23f59f6 100644 --- a/lib/CodeGen/LiveIntervalAnalysis.cpp +++ b/lib/CodeGen/LiveIntervalAnalysis.cpp @@ -45,6 +45,7 @@ STATISTIC(numFolded , "Number of loads/stores folded into instructions"); STATISTIC(numAborts , "Number of times interval joining aborted"); namespace { + const int LiveIntervals::ID = 0; RegisterPass X("liveintervals", "Live Interval Analysis"); static cl::opt diff --git a/lib/CodeGen/LiveVariables.cpp b/lib/CodeGen/LiveVariables.cpp index 4816cc12577..3ea60bcf15c 100644 --- a/lib/CodeGen/LiveVariables.cpp +++ b/lib/CodeGen/LiveVariables.cpp @@ -37,6 +37,7 @@ #include using namespace llvm; +const int LiveVariables::ID = 0; static RegisterPass X("livevars", "Live Variable Analysis"); void LiveVariables::VarInfo::dump() const { diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp index 5164103d273..f8dccc1895e 100644 --- a/lib/CodeGen/MachOWriter.cpp +++ b/lib/CodeGen/MachOWriter.cpp @@ -317,7 +317,9 @@ void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) { // MachOWriter Implementation //===----------------------------------------------------------------------===// -MachOWriter::MachOWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) { +const int MachOWriter::ID = 0; +MachOWriter::MachOWriter(std::ostream &o, TargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) { is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64; isLittleEndian = TM.getTargetData()->isLittleEndian(); diff --git a/lib/CodeGen/MachOWriter.h b/lib/CodeGen/MachOWriter.h index 0792ac8a7df..d4c146d3bfe 100644 --- a/lib/CodeGen/MachOWriter.h +++ b/lib/CodeGen/MachOWriter.h @@ -84,6 +84,7 @@ namespace llvm { class MachOWriter : public MachineFunctionPass { friend class MachOCodeEmitter; public: + static const int ID; MachineCodeEmitter &getMachineCodeEmitter() const { return *(MachineCodeEmitter*)MCE; } diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp index 29eee3612f6..9b43e655bc9 100644 --- a/lib/CodeGen/MachineFunction.cpp +++ b/lib/CodeGen/MachineFunction.cpp @@ -44,11 +44,13 @@ void MachineFunctionPass::virtfn() {} namespace { struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass { + static const int ID; + std::ostream *OS; const std::string Banner; - Printer (std::ostream *_OS, const std::string &_Banner) : - OS (_OS), Banner (_Banner) { } + Printer (std::ostream *_OS, const std::string &_Banner) + : MachineFunctionPass((intptr_t)&ID), OS (_OS), Banner (_Banner) { } const char *getPassName() const { return "MachineFunction Printer"; } @@ -62,6 +64,7 @@ namespace { return false; } }; + const int Printer::ID = 0; } /// Returns a newly-created MachineFunction Printer pass. The default output @@ -74,6 +77,9 @@ FunctionPass *llvm::createMachineFunctionPrinterPass(std::ostream *OS, namespace { struct VISIBILITY_HIDDEN Deleter : public MachineFunctionPass { + static const int ID; + Deleter() : MachineFunctionPass((intptr_t)&ID) {} + const char *getPassName() const { return "Machine Code Deleter"; } bool runOnMachineFunction(MachineFunction &MF) { @@ -82,6 +88,7 @@ namespace { return true; } }; + const int Deleter::ID = 0; } /// MachineCodeDeletion Pass - This pass deletes all of the machine code for diff --git a/lib/CodeGen/MachineModuleInfo.cpp b/lib/CodeGen/MachineModuleInfo.cpp index d37021e0a31..6421396faac 100644 --- a/lib/CodeGen/MachineModuleInfo.cpp +++ b/lib/CodeGen/MachineModuleInfo.cpp @@ -28,6 +28,7 @@ using namespace llvm::dwarf; // Handle the Pass registration stuff necessary to use TargetData's. namespace { + const int MachineModuleInfo::ID = 0; RegisterPass X("machinemoduleinfo", "Module Information"); } @@ -1462,7 +1463,8 @@ DebugScope::~DebugScope() { //===----------------------------------------------------------------------===// MachineModuleInfo::MachineModuleInfo() -: DR() +: ImmutablePass((intptr_t)&ID) +, DR() , VR() , CompileUnits() , Directories() @@ -1749,10 +1751,15 @@ Function *MachineModuleInfo::getPersonality() const { namespace llvm { struct DebugLabelFolder : public MachineFunctionPass { + static const int ID; + DebugLabelFolder() : MachineFunctionPass((intptr_t)&ID) {} + virtual bool runOnMachineFunction(MachineFunction &MF); virtual const char *getPassName() const { return "Label Folder"; } }; +const int DebugLabelFolder::ID = 0; + bool DebugLabelFolder::runOnMachineFunction(MachineFunction &MF) { // Get machine module info. MachineModuleInfo *MMI = getAnalysisToUpdate(); diff --git a/lib/CodeGen/PHIElimination.cpp b/lib/CodeGen/PHIElimination.cpp index 0b77fe26696..f26819d9e29 100644 --- a/lib/CodeGen/PHIElimination.cpp +++ b/lib/CodeGen/PHIElimination.cpp @@ -33,6 +33,9 @@ STATISTIC(NumAtomic, "Number of atomic phis lowered"); namespace { struct VISIBILITY_HIDDEN PNE : public MachineFunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + PNE() : MachineFunctionPass((intptr_t)&ID) {} + bool runOnMachineFunction(MachineFunction &Fn) { analyzePHINodes(Fn); @@ -73,6 +76,7 @@ namespace { VRegPHIUse VRegPHIUseCount; }; + const int PNE::ID = 0; RegisterPass X("phi-node-elimination", "Eliminate PHI nodes for register allocation"); } diff --git a/lib/CodeGen/PrologEpilogInserter.cpp b/lib/CodeGen/PrologEpilogInserter.cpp index 98c2085ccd8..927f7d12269 100644 --- a/lib/CodeGen/PrologEpilogInserter.cpp +++ b/lib/CodeGen/PrologEpilogInserter.cpp @@ -32,6 +32,9 @@ using namespace llvm; namespace { struct VISIBILITY_HIDDEN PEI : public MachineFunctionPass { + static const int ID; + PEI() : MachineFunctionPass((intptr_t)&ID) {} + const char *getPassName() const { return "Prolog/Epilog Insertion & Frame Finalization"; } @@ -98,6 +101,7 @@ namespace { void replaceFrameIndices(MachineFunction &Fn); void insertPrologEpilogCode(MachineFunction &Fn); }; + const int PEI::ID = 0; } diff --git a/lib/CodeGen/RegAllocLinearScan.cpp b/lib/CodeGen/RegAllocLinearScan.cpp index 8ad347bb7da..b45d983eebe 100644 --- a/lib/CodeGen/RegAllocLinearScan.cpp +++ b/lib/CodeGen/RegAllocLinearScan.cpp @@ -48,6 +48,9 @@ namespace { static unsigned numIntervals = 0; struct VISIBILITY_HIDDEN RA : public MachineFunctionPass { + static const int ID; + RA() : MachineFunctionPass((intptr_t)&ID) {} + typedef std::pair IntervalPtr; typedef std::vector IntervalPtrs; private: @@ -146,6 +149,7 @@ namespace { } } }; + const int RA::ID = 0; } void RA::ComputeRelatedRegClasses() { diff --git a/lib/CodeGen/RegAllocLocal.cpp b/lib/CodeGen/RegAllocLocal.cpp index d3d5796e851..4494552c9f2 100644 --- a/lib/CodeGen/RegAllocLocal.cpp +++ b/lib/CodeGen/RegAllocLocal.cpp @@ -43,6 +43,10 @@ namespace { class VISIBILITY_HIDDEN RA : public MachineFunctionPass { + public: + static const int ID; + RA() : MachineFunctionPass((intptr_t)&ID) {} + private: const TargetMachine *TM; MachineFunction *MF; const MRegisterInfo *RegInfo; @@ -224,6 +228,7 @@ namespace { void reloadPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I, unsigned PhysReg); }; + const int RA::ID = 0; } /// getStackSpaceFor - This allocates space for the specified virtual register diff --git a/lib/CodeGen/RegAllocSimple.cpp b/lib/CodeGen/RegAllocSimple.cpp index 576d2b421c5..771c68b1acc 100644 --- a/lib/CodeGen/RegAllocSimple.cpp +++ b/lib/CodeGen/RegAllocSimple.cpp @@ -38,6 +38,10 @@ namespace { createSimpleRegisterAllocator); class VISIBILITY_HIDDEN RegAllocSimple : public MachineFunctionPass { + public: + static const int ID; + RegAllocSimple() : MachineFunctionPass((intptr_t)&ID) {} + private: MachineFunction *MF; const TargetMachine *TM; const MRegisterInfo *RegInfo; @@ -90,7 +94,7 @@ namespace { void spillVirtReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, unsigned VirtReg, unsigned PhysReg); }; - + const int RegAllocSimple::ID = 0; } /// getStackSpaceFor - This allocates space for the specified virtual diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp index 7f710040fe5..c83eb5bb3da 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -5011,3 +5011,5 @@ SelectInlineAsmMemoryOperands(std::vector &Ops, SelectionDAG &DAG) { if (e != InOps.size()) Ops.push_back(InOps.back()); } + +const int SelectionDAGISel::ID = 0; diff --git a/lib/CodeGen/TwoAddressInstructionPass.cpp b/lib/CodeGen/TwoAddressInstructionPass.cpp index b14a95e406c..455993c45d7 100644 --- a/lib/CodeGen/TwoAddressInstructionPass.cpp +++ b/lib/CodeGen/TwoAddressInstructionPass.cpp @@ -50,12 +50,16 @@ STATISTIC(NumConvertedTo3Addr, "Number of instructions promoted to 3-address"); namespace { struct VISIBILITY_HIDDEN TwoAddressInstructionPass : public MachineFunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + TwoAddressInstructionPass() : MachineFunctionPass((intptr_t)&ID) {} + virtual void getAnalysisUsage(AnalysisUsage &AU) const; /// runOnMachineFunction - pass entry point bool runOnMachineFunction(MachineFunction&); }; + const int TwoAddressInstructionPass::ID = 0; RegisterPass X("twoaddressinstruction", "Two-Address instruction pass"); } diff --git a/lib/CodeGen/UnreachableBlockElim.cpp b/lib/CodeGen/UnreachableBlockElim.cpp index 951deb60d96..f66a7713d7f 100644 --- a/lib/CodeGen/UnreachableBlockElim.cpp +++ b/lib/CodeGen/UnreachableBlockElim.cpp @@ -34,7 +34,11 @@ using namespace llvm; namespace { class VISIBILITY_HIDDEN UnreachableBlockElim : public FunctionPass { virtual bool runOnFunction(Function &F); + public: + static const int ID; // Pass identifcation, replacement for typeid + UnreachableBlockElim() : FunctionPass((intptr_t)&ID) {} }; + const int UnreachableBlockElim::ID = 0; RegisterPass X("unreachableblockelim", "Remove unreachable blocks from the CFG"); } diff --git a/lib/Target/ARM/ARMConstantIslandPass.cpp b/lib/Target/ARM/ARMConstantIslandPass.cpp index 9237228a91c..0850d229945 100644 --- a/lib/Target/ARM/ARMConstantIslandPass.cpp +++ b/lib/Target/ARM/ARMConstantIslandPass.cpp @@ -128,6 +128,9 @@ namespace { ARMFunctionInfo *AFI; bool isThumb; public: + static const int ID; + ARMConstantIslands() : MachineFunctionPass((intptr_t)&ID) {} + virtual bool runOnMachineFunction(MachineFunction &Fn); virtual const char *getPassName() const { @@ -171,6 +174,7 @@ namespace { void dumpBBs(); void verify(MachineFunction &Fn); }; + const int ARMConstantIslands::ID = 0; } /// verify - check BBOffsets, BBSizes, alignment of islands diff --git a/lib/Target/ARM/ARMLoadStoreOptimizer.cpp b/lib/Target/ARM/ARMLoadStoreOptimizer.cpp index 3f8f35016d1..143fa1bbdaa 100644 --- a/lib/Target/ARM/ARMLoadStoreOptimizer.cpp +++ b/lib/Target/ARM/ARMLoadStoreOptimizer.cpp @@ -38,6 +38,9 @@ STATISTIC(NumFSTMGened, "Number of fstm instructions generated"); namespace { struct VISIBILITY_HIDDEN ARMLoadStoreOpt : public MachineFunctionPass { + static const int ID; + ARMLoadStoreOpt() : MachineFunctionPass((intptr_t)&ID) {} + const TargetInstrInfo *TII; const MRegisterInfo *MRI; ARMFunctionInfo *AFI; @@ -70,6 +73,7 @@ namespace { bool LoadStoreMultipleOpti(MachineBasicBlock &MBB); bool MergeReturnIntoLDM(MachineBasicBlock &MBB); }; + const int ARMLoadStoreOpt::ID = 0; } /// createARMLoadStoreOptimizationPass - returns an instance of the load / store diff --git a/lib/Target/Alpha/AlphaBranchSelector.cpp b/lib/Target/Alpha/AlphaBranchSelector.cpp index 65bacb8a749..f0f70adffef 100644 --- a/lib/Target/Alpha/AlphaBranchSelector.cpp +++ b/lib/Target/Alpha/AlphaBranchSelector.cpp @@ -22,6 +22,8 @@ using namespace llvm; namespace { struct VISIBILITY_HIDDEN AlphaBSel : public MachineFunctionPass { + static const int ID; + AlphaBSel() : MachineFunctionPass((intptr_t)&ID) {} virtual bool runOnMachineFunction(MachineFunction &Fn); @@ -29,6 +31,7 @@ namespace { return "Alpha Branch Selection"; } }; + const int AlphaBSel::ID = 0; } /// createAlphaBranchSelectionPass - returns an instance of the Branch Selection diff --git a/lib/Target/Alpha/AlphaCodeEmitter.cpp b/lib/Target/Alpha/AlphaCodeEmitter.cpp index 15aef8532d5..006e57176e0 100644 --- a/lib/Target/Alpha/AlphaCodeEmitter.cpp +++ b/lib/Target/Alpha/AlphaCodeEmitter.cpp @@ -36,11 +36,12 @@ namespace { int getMachineOpValue(MachineInstr &MI, MachineOperand &MO); public: + static const int ID; explicit AlphaCodeEmitter(TargetMachine &tm, MachineCodeEmitter &mce) - : II(0), TM(tm), MCE(mce) {} + : MachineFunctionPass((intptr_t)&ID), II(0), TM(tm), MCE(mce) {} AlphaCodeEmitter(TargetMachine &tm, MachineCodeEmitter &mce, const AlphaInstrInfo& ii) - : II(&ii), TM(tm), MCE(mce) {} + : MachineFunctionPass((intptr_t)&ID), II(&ii), TM(tm), MCE(mce) {} bool runOnMachineFunction(MachineFunction &MF); @@ -60,6 +61,7 @@ namespace { void emitBasicBlock(MachineBasicBlock &MBB); }; + const int AlphaCodeEmitter::ID = 0; } /// createAlphaCodeEmitterPass - Return a pass that emits the collected Alpha code diff --git a/lib/Target/Alpha/AlphaLLRP.cpp b/lib/Target/Alpha/AlphaLLRP.cpp index 6d2d243e3d0..c5a20e7a0c6 100644 --- a/lib/Target/Alpha/AlphaLLRP.cpp +++ b/lib/Target/Alpha/AlphaLLRP.cpp @@ -37,7 +37,9 @@ namespace { /// AlphaTargetMachine &TM; - AlphaLLRPPass(AlphaTargetMachine &tm) : TM(tm) { } + static const int ID; + AlphaLLRPPass(AlphaTargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), TM(tm) { } virtual const char *getPassName() const { return "Alpha NOP inserter"; @@ -152,6 +154,7 @@ namespace { return Changed; } }; + const int AlphaLLRPPass::ID = 0; } // end of anonymous namespace FunctionPass *llvm::createAlphaLLRPPass(AlphaTargetMachine &tm) { diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index ac7251f8982..e29edff13b5 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -56,6 +56,10 @@ namespace { /// external functions with the same name. /// class CBackendNameAllUsedStructsAndMergeFunctions : public ModulePass { + public: + static const int ID; + CBackendNameAllUsedStructsAndMergeFunctions() + : ModulePass((intptr_t)&ID) {} void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); } @@ -67,6 +71,8 @@ namespace { virtual bool runOnModule(Module &M); }; + const int CBackendNameAllUsedStructsAndMergeFunctions::ID = 0; + /// CWriter - This class is the main chunk of code that converts an LLVM /// module to a C translation unit. class CWriter : public FunctionPass, public InstVisitor { @@ -82,8 +88,10 @@ namespace { std::set intrinsicPrototypesAlreadyGenerated; public: - CWriter(std::ostream &o) : Out(o), IL(0), Mang(0), LI(0), TheModule(0), - TAsm(0), TD(0) {} + static const int ID; + CWriter(std::ostream &o) + : FunctionPass((intptr_t)&ID), Out(o), IL(0), Mang(0), LI(0), + TheModule(0), TAsm(0), TD(0) {} virtual const char *getPassName() const { return "C backend"; } @@ -256,6 +264,8 @@ namespace { }; } +const int CWriter::ID = 0; + /// This method inserts names for any unnamed structure types that are used by /// the program, and removes names from structure types that are not used by the /// program. diff --git a/lib/Target/IA64/IA64Bundling.cpp b/lib/Target/IA64/IA64Bundling.cpp index 08e4ba8d376..89732aed5f3 100644 --- a/lib/Target/IA64/IA64Bundling.cpp +++ b/lib/Target/IA64/IA64Bundling.cpp @@ -36,12 +36,14 @@ STATISTIC(StopBitsAdded, "Number of stop bits added"); namespace { struct IA64BundlingPass : public MachineFunctionPass { + static const int ID; /// Target machine description which we query for reg. names, data /// layout, etc. /// IA64TargetMachine &TM; - IA64BundlingPass(IA64TargetMachine &tm) : TM(tm) { } + IA64BundlingPass(IA64TargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), TM(tm) { } virtual const char *getPassName() const { return "IA64 (Itanium) Bundling Pass"; @@ -61,6 +63,7 @@ namespace { // 'fallthrough' code std::set PendingRegWrites; }; + const int IA64BundlingPass::ID = 0; } // end of anonymous namespace /// createIA64BundlingPass - Returns a pass that adds STOP (;;) instructions diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp index 55eb03c7d01..86bea59db42 100644 --- a/lib/Target/MSIL/MSILWriter.cpp +++ b/lib/Target/MSIL/MSILWriter.cpp @@ -80,6 +80,8 @@ bool MSILModule::runOnModule(Module &M) { return Changed; } +const int MSILModule::ID = 0; +const int MSILWriter::ID = 0; bool MSILWriter::runOnFunction(Function &F) { if (F.isDeclaration()) return false; diff --git a/lib/Target/MSIL/MSILWriter.h b/lib/Target/MSIL/MSILWriter.h index 7fa039e3d9d..15a463d73dd 100644 --- a/lib/Target/MSIL/MSILWriter.h +++ b/lib/Target/MSIL/MSILWriter.h @@ -37,9 +37,10 @@ namespace { const TargetData*& TD; public: + static const int ID; MSILModule(const std::set*& _UsedTypes, const TargetData*& _TD) - : UsedTypes(_UsedTypes), TD(_TD) {} + : ModulePass((intptr_t)&ID), UsedTypes(_UsedTypes), TD(_TD) {} void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); @@ -82,8 +83,8 @@ namespace { std::map > StaticInitList; const std::set* UsedTypes; - - MSILWriter(std::ostream &o) : Out(o) { + static const int ID; + MSILWriter(std::ostream &o) : FunctionPass((intptr_t)&ID), Out(o) { UniqID = 0; } diff --git a/lib/Target/PowerPC/PPCBranchSelector.cpp b/lib/Target/PowerPC/PPCBranchSelector.cpp index 2cd8325ce3d..a4f0caee8a6 100644 --- a/lib/Target/PowerPC/PPCBranchSelector.cpp +++ b/lib/Target/PowerPC/PPCBranchSelector.cpp @@ -32,6 +32,9 @@ STATISTIC(NumExpanded, "Number of branches expanded to long format"); namespace { struct VISIBILITY_HIDDEN PPCBSel : public MachineFunctionPass { + static const int ID; + PPCBSel() : MachineFunctionPass((intptr_t)&ID) {} + /// BlockSizes - The sizes of the basic blocks in the function. std::vector BlockSizes; @@ -41,6 +44,7 @@ namespace { return "PowerPC Branch Selector"; } }; + const int PPCBSel::ID = 0; } /// createPPCBranchSelectionPass - returns an instance of the Branch Selection diff --git a/lib/Target/PowerPC/PPCCodeEmitter.cpp b/lib/Target/PowerPC/PPCCodeEmitter.cpp index 6e3d68d0477..acca7a30ebc 100644 --- a/lib/Target/PowerPC/PPCCodeEmitter.cpp +++ b/lib/Target/PowerPC/PPCCodeEmitter.cpp @@ -40,8 +40,9 @@ namespace { int getMachineOpValue(MachineInstr &MI, MachineOperand &MO); public: + static const int ID; PPCCodeEmitter(TargetMachine &T, MachineCodeEmitter &M) - : TM(T), MCE(M) {} + : MachineFunctionPass((intptr_t)&ID), TM(T), MCE(M) {} const char *getPassName() const { return "PowerPC Machine Code Emitter"; } @@ -63,6 +64,7 @@ namespace { /// unsigned getBinaryCodeForInstr(MachineInstr &MI); }; + const int PPCCodeEmitter::ID = 0; } /// createPPCCodeEmitterPass - Return a pass that emits the collected PPC code diff --git a/lib/Target/Sparc/DelaySlotFiller.cpp b/lib/Target/Sparc/DelaySlotFiller.cpp index 898b23ab50f..313eab9319f 100644 --- a/lib/Target/Sparc/DelaySlotFiller.cpp +++ b/lib/Target/Sparc/DelaySlotFiller.cpp @@ -30,7 +30,9 @@ namespace { TargetMachine &TM; const TargetInstrInfo *TII; - Filler(TargetMachine &tm) : TM(tm), TII(tm.getInstrInfo()) { } + static const int ID; + Filler(TargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), TM(tm), TII(tm.getInstrInfo()) { } virtual const char *getPassName() const { return "SPARC Delay Slot Filler"; @@ -46,6 +48,7 @@ namespace { } }; + const int Filler::ID = 0; } // end of anonymous namespace /// createSparcDelaySlotFillerPass - Returns a pass that fills in delay diff --git a/lib/Target/Sparc/FPMover.cpp b/lib/Target/Sparc/FPMover.cpp index f7e6506de43..5596586f0c0 100644 --- a/lib/Target/Sparc/FPMover.cpp +++ b/lib/Target/Sparc/FPMover.cpp @@ -31,8 +31,10 @@ namespace { /// layout, etc. /// TargetMachine &TM; - - FPMover(TargetMachine &tm) : TM(tm) { } + + static const int ID; + FPMover(TargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), TM(tm) { } virtual const char *getPassName() const { return "Sparc Double-FP Move Fixer"; @@ -41,6 +43,7 @@ namespace { bool runOnMachineBasicBlock(MachineBasicBlock &MBB); bool runOnMachineFunction(MachineFunction &F); }; + const int FPMover::ID = 0; } // end of anonymous namespace /// createSparcFPMoverPass - Returns a pass that turns FpMOVD diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp index 2cbb903b963..d1842fe7de2 100644 --- a/lib/Target/TargetData.cpp +++ b/lib/Target/TargetData.cpp @@ -33,6 +33,7 @@ using namespace llvm; // Handle the Pass registration stuff necessary to use TargetData's. namespace { // Register the default SparcV9 implementation... + const int TargetData::ID = 0; RegisterPass X("targetdata", "Target Data Layout"); } @@ -221,7 +222,8 @@ void TargetData::init(const std::string &TargetDescription) { } } -TargetData::TargetData(const Module *M) { +TargetData::TargetData(const Module *M) + : ImmutablePass((intptr_t)&ID) { init(M->getDataLayout()); } diff --git a/lib/Target/X86/X86CodeEmitter.cpp b/lib/Target/X86/X86CodeEmitter.cpp index 7371aada077..db80d9f892e 100644 --- a/lib/Target/X86/X86CodeEmitter.cpp +++ b/lib/Target/X86/X86CodeEmitter.cpp @@ -39,11 +39,14 @@ namespace { MachineCodeEmitter &MCE; bool Is64BitMode; public: + static const int ID; explicit Emitter(TargetMachine &tm, MachineCodeEmitter &mce) - : II(0), TD(0), TM(tm), MCE(mce), Is64BitMode(false) {} + : MachineFunctionPass((intptr_t)&ID), II(0), TD(0), TM(tm), + MCE(mce), Is64BitMode(false) {} Emitter(TargetMachine &tm, MachineCodeEmitter &mce, const X86InstrInfo &ii, const TargetData &td, bool is64) - : II(&ii), TD(&td), TM(tm), MCE(mce), Is64BitMode(is64) {} + : MachineFunctionPass((intptr_t)&ID), II(&ii), TD(&td), TM(tm), + MCE(mce), Is64BitMode(is64) {} bool runOnMachineFunction(MachineFunction &MF); @@ -79,6 +82,7 @@ namespace { bool isX86_64ExtendedReg(const MachineOperand &MO); unsigned determineREX(const MachineInstr &MI); }; + const int Emitter::ID = 0; } /// createX86CodeEmitterPass - Return a pass that emits the collected X86 code diff --git a/lib/Target/X86/X86FloatingPoint.cpp b/lib/Target/X86/X86FloatingPoint.cpp index 2439d19234c..4667b91ba62 100644 --- a/lib/Target/X86/X86FloatingPoint.cpp +++ b/lib/Target/X86/X86FloatingPoint.cpp @@ -52,6 +52,9 @@ STATISTIC(NumFP , "Number of floating point instructions"); namespace { struct VISIBILITY_HIDDEN FPS : public MachineFunctionPass { + static const int ID; + FPS() : MachineFunctionPass((intptr_t)&ID) {} + virtual bool runOnMachineFunction(MachineFunction &MF); virtual const char *getPassName() const { return "X86 FP Stackifier"; } @@ -151,6 +154,7 @@ namespace { void handleCondMovFP(MachineBasicBlock::iterator &I); void handleSpecialFP(MachineBasicBlock::iterator &I); }; + const int FPS::ID = 0; } FunctionPass *llvm::createX86FloatingPointStackifierPass() { return new FPS(); } diff --git a/lib/Transforms/Hello/Hello.cpp b/lib/Transforms/Hello/Hello.cpp index df8866279f2..d9af9df18b5 100644 --- a/lib/Transforms/Hello/Hello.cpp +++ b/lib/Transforms/Hello/Hello.cpp @@ -25,6 +25,9 @@ STATISTIC(HelloCounter, "Counts number of functions greeted"); namespace { // Hello - The first implementation, without getAnalysisUsage. struct Hello : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + Hello() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F) { HelloCounter++; std::string fname = F.getName(); @@ -33,10 +36,15 @@ namespace { return false; } }; + + const int Hello::ID = 0; RegisterPass X("hello", "Hello World Pass"); // Hello2 - The second implementation with getAnalysisUsage implemented. struct Hello2 : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + Hello2() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F) { HelloCounter++; std::string fname = F.getName(); @@ -50,6 +58,7 @@ namespace { AU.setPreservesAll(); }; }; + const int Hello2::ID = 0; RegisterPass Y("hello2", "Hello World Pass (with getAnalysisUsage implemented)"); } diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp index e1fe118686e..6310e5dc0fe 100644 --- a/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -63,12 +63,16 @@ namespace { } virtual bool runOnSCC(const std::vector &SCC); + static const int ID; // Pass identifcation, replacement for typeid + ArgPromotion() : CallGraphSCCPass((intptr_t)&ID) {} + private: bool PromoteArguments(CallGraphNode *CGN); bool isSafeToPromoteArgument(Argument *Arg) const; Function *DoPromotion(Function *F, std::vector &ArgsToPromote); }; + const int ArgPromotion::ID = 0; RegisterPass X("argpromotion", "Promote 'by reference' arguments to scalars"); } diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp index 400b5e20312..5c226438c2b 100644 --- a/lib/Transforms/IPO/ConstantMerge.cpp +++ b/lib/Transforms/IPO/ConstantMerge.cpp @@ -29,12 +29,16 @@ STATISTIC(NumMerged, "Number of global constants merged"); namespace { struct VISIBILITY_HIDDEN ConstantMerge : public ModulePass { + static const int ID; // Pass identifcation, replacement for typeid + ConstantMerge() : ModulePass((intptr_t)&ID) {} + // run - For this pass, process all of the globals in the module, // eliminating duplicate constants. // bool runOnModule(Module &M); }; + const int ConstantMerge::ID = 0; RegisterPassX("constmerge","Merge Duplicate Global Constants"); } diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp index d0dbc8b4288..162d078514e 100644 --- a/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -76,6 +76,8 @@ namespace { std::multimap CallSites; public: + static const int ID; // Pass identifcation, replacement for typeid + DAE() : ModulePass((intptr_t)&ID) {} bool runOnModule(Module &M); virtual bool ShouldHackArguments() const { return false; } @@ -93,14 +95,17 @@ namespace { void RemoveDeadArgumentsFromFunction(Function *F); }; + const int DAE::ID = 0; RegisterPass X("deadargelim", "Dead Argument Elimination"); /// DAH - DeadArgumentHacking pass - Same as dead argument elimination, but /// deletes arguments to functions which are external. This is only for use /// by bugpoint. struct DAH : public DAE { + static const int ID; virtual bool ShouldHackArguments() const { return true; } }; + const int DAH::ID = 0; RegisterPass Y("deadarghaX0r", "Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)"); } diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index a72a48cc635..8ecd4b7688e 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -26,6 +26,9 @@ STATISTIC(NumKilled, "Number of unused typenames removed from symtab"); namespace { struct VISIBILITY_HIDDEN DTE : public ModulePass { + static const int ID; // Pass identifcation, replacement for typeid + DTE() : ModulePass((intptr_t)&ID) {} + // 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. @@ -40,6 +43,7 @@ namespace { AU.addRequired(); } }; + const int DTE::ID = 0; RegisterPass X("deadtypeelim", "Dead Type Elimination"); } diff --git a/lib/Transforms/IPO/ExtractFunction.cpp b/lib/Transforms/IPO/ExtractFunction.cpp index afaf38d2808..7a4765533ee 100644 --- a/lib/Transforms/IPO/ExtractFunction.cpp +++ b/lib/Transforms/IPO/ExtractFunction.cpp @@ -25,13 +25,16 @@ namespace { bool deleteFunc; bool reLink; public: + static const int ID; // Pass identifcation, replacement for typeid + /// FunctionExtractorPass - If deleteFn is true, this pass deletes as the /// specified function. Otherwise, it deletes as much of the module as /// possible, except for the function specified. /// FunctionExtractorPass(Function *F = 0, bool deleteFn = true, bool relinkCallees = false) - : Named(F), deleteFunc(deleteFn), reLink(relinkCallees) {} + : ModulePass((intptr_t)&ID), Named(F), deleteFunc(deleteFn), + reLink(relinkCallees) {} bool runOnModule(Module &M) { if (Named == 0) { @@ -131,6 +134,7 @@ namespace { } }; + const int FunctionExtractorPass::ID = 0; RegisterPass X("extract", "Function Extractor"); } diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp index 56879e2b136..00b16a839e3 100644 --- a/lib/Transforms/IPO/GlobalDCE.cpp +++ b/lib/Transforms/IPO/GlobalDCE.cpp @@ -30,6 +30,9 @@ STATISTIC(NumVariables, "Number of global variables removed"); namespace { struct VISIBILITY_HIDDEN GlobalDCE : public ModulePass { + static const int ID; // Pass identifcation, replacement for typeid + GlobalDCE() : ModulePass((intptr_t)&ID) {} + // run - Do the GlobalDCE pass on the specified module, optionally updating // the specified callgraph to reflect the changes. // @@ -46,6 +49,7 @@ namespace { bool SafeToDestroyConstant(Constant* C); bool RemoveUnusedGlobalValue(GlobalValue &GV); }; + const int GlobalDCE::ID = 0; RegisterPass X("globaldce", "Dead Global Elimination"); } diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp index 9ac36548708..cfa8998b2f9 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -50,6 +50,8 @@ namespace { virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); } + static const int ID; // Pass identifcation, replacement for typeid + GlobalOpt() : ModulePass((intptr_t)&ID) {} bool runOnModule(Module &M); @@ -61,6 +63,7 @@ namespace { bool ProcessInternalGlobal(GlobalVariable *GV,Module::global_iterator &GVI); }; + const int GlobalOpt::ID = 0; RegisterPass X("globalopt", "Global Variable Optimizer"); } diff --git a/lib/Transforms/IPO/IPConstantPropagation.cpp b/lib/Transforms/IPO/IPConstantPropagation.cpp index af4fb69c821..9ef775660a6 100644 --- a/lib/Transforms/IPO/IPConstantPropagation.cpp +++ b/lib/Transforms/IPO/IPConstantPropagation.cpp @@ -33,11 +33,15 @@ namespace { /// IPCP - The interprocedural constant propagation pass /// struct VISIBILITY_HIDDEN IPCP : public ModulePass { + static const int ID; // Pass identifcation, replacement for typeid + IPCP() : ModulePass((intptr_t)&ID) {} + bool runOnModule(Module &M); private: bool PropagateConstantsIntoArguments(Function &F); bool PropagateConstantReturn(Function &F); }; + const int IPCP::ID = 0; RegisterPass X("ipconstprop", "Interprocedural constant propagation"); } diff --git a/lib/Transforms/IPO/IndMemRemoval.cpp b/lib/Transforms/IPO/IndMemRemoval.cpp index eeddad71a97..20d11178bf9 100644 --- a/lib/Transforms/IPO/IndMemRemoval.cpp +++ b/lib/Transforms/IPO/IndMemRemoval.cpp @@ -32,8 +32,12 @@ STATISTIC(NumBounce , "Number of bounce functions created"); namespace { class VISIBILITY_HIDDEN IndMemRemPass : public ModulePass { public: + static const int ID; // Pass identifcation, replacement for typeid + IndMemRemPass() : ModulePass((intptr_t)&ID) {} + virtual bool runOnModule(Module &M); }; + const int IndMemRemPass::ID = 0; RegisterPass X("indmemrem","Indirect Malloc and Free Removal"); } // end anonymous namespace diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index 64de9c395e3..8f9a1f64d91 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -54,8 +54,10 @@ namespace { class VISIBILITY_HIDDEN SimpleInliner : public Inliner { std::map CachedFunctionInfo; public: + static const int ID; // Pass identifcation, replacement for typeid int getInlineCost(CallSite CS); }; + const int SimpleInliner::ID = 0; RegisterPass X("inline", "Function Integration/Inlining"); } diff --git a/lib/Transforms/IPO/Inliner.cpp b/lib/Transforms/IPO/Inliner.cpp index 5990b65837d..82611cbc8ff 100644 --- a/lib/Transforms/IPO/Inliner.cpp +++ b/lib/Transforms/IPO/Inliner.cpp @@ -36,7 +36,9 @@ namespace { cl::desc("Control the amount of inlining to perform (default = 200)")); } -Inliner::Inliner() : InlineThreshold(InlineLimit) {} +const int Inliner::ID = 0; +Inliner::Inliner() + : CallGraphSCCPass((intptr_t)&ID), InlineThreshold(InlineLimit) {} /// getAnalysisUsage - For this class, we declare that we require and preserve /// the call graph. If the derived class implements this method, it should diff --git a/lib/Transforms/IPO/Inliner.h b/lib/Transforms/IPO/Inliner.h index a59f80b86d2..321a65f4888 100644 --- a/lib/Transforms/IPO/Inliner.h +++ b/lib/Transforms/IPO/Inliner.h @@ -27,6 +27,7 @@ namespace llvm { /// perform the inlining operations that does not depend on the policy. /// struct Inliner : public CallGraphSCCPass { + static const int ID; Inliner(); /// getAnalysisUsage - For this class, we declare that we require and preserve diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp index 46d80e592ff..17de131590f 100644 --- a/lib/Transforms/IPO/Internalize.cpp +++ b/lib/Transforms/IPO/Internalize.cpp @@ -46,16 +46,18 @@ namespace { std::set ExternalNames; bool DontInternalize; public: + static const int ID; // Pass identifcation, replacement for typeid InternalizePass(bool InternalizeEverything = true); InternalizePass(const std::vector & exportList); void LoadFile(const char *Filename); virtual bool runOnModule(Module &M); }; + const int InternalizePass::ID = 0; RegisterPass X("internalize", "Internalize Global Symbols"); } // end anonymous namespace InternalizePass::InternalizePass(bool InternalizeEverything) - : DontInternalize(false){ + : ModulePass((intptr_t)&ID), DontInternalize(false){ if (!APIFile.empty()) // If a filename is specified, use it LoadFile(APIFile.c_str()); else if (!APIList.empty()) // Else, if a list is specified, use it. @@ -66,7 +68,7 @@ InternalizePass::InternalizePass(bool InternalizeEverything) } InternalizePass::InternalizePass(const std::vector&exportList) - : DontInternalize(false){ + : ModulePass((intptr_t)&ID), DontInternalize(false){ for(std::vector::const_iterator itr = exportList.begin(); itr != exportList.end(); itr++) { ExternalNames.insert(*itr); diff --git a/lib/Transforms/IPO/LoopExtractor.cpp b/lib/Transforms/IPO/LoopExtractor.cpp index c5f4fca12af..0ea544daa60 100644 --- a/lib/Transforms/IPO/LoopExtractor.cpp +++ b/lib/Transforms/IPO/LoopExtractor.cpp @@ -34,9 +34,11 @@ namespace { // Module passes to require FunctionPasses, so we can't get loop info if we're // not a function pass. struct VISIBILITY_HIDDEN LoopExtractor : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid unsigned NumLoops; - LoopExtractor(unsigned numLoops = ~0) : NumLoops(numLoops) {} + LoopExtractor(unsigned numLoops = ~0) + : FunctionPass((intptr_t)&ID), NumLoops(numLoops) {} virtual bool runOnFunction(Function &F); @@ -49,14 +51,17 @@ namespace { } }; + const int LoopExtractor::ID = 0; RegisterPass X("loop-extract", "Extract loops into new functions"); /// SingleLoopExtractor - For bugpoint. struct SingleLoopExtractor : public LoopExtractor { + static const int ID; // Pass identifcation, replacement for typeid SingleLoopExtractor() : LoopExtractor(1) {} }; + const int SingleLoopExtractor::ID = 0; RegisterPass Y("loop-extract-single", "Extract at most one loop into a new function"); } // End anonymous namespace @@ -147,11 +152,15 @@ namespace { class BlockExtractorPass : public ModulePass { std::vector BlocksToNotExtract; public: - BlockExtractorPass(std::vector &B) : BlocksToNotExtract(B) {} - BlockExtractorPass() {} + static const int ID; // Pass identifcation, replacement for typeid + BlockExtractorPass(std::vector &B) + : ModulePass((intptr_t)&ID), BlocksToNotExtract(B) {} + BlockExtractorPass() : ModulePass((intptr_t)&ID) {} bool runOnModule(Module &M); }; + + const int BlockExtractorPass::ID = 0; RegisterPass XX("extract-blocks", "Extract Basic Blocks From Module (for bugpoint use)"); } diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp index 3f32c0c76d5..010bc592afc 100644 --- a/lib/Transforms/IPO/LowerSetJmp.cpp +++ b/lib/Transforms/IPO/LowerSetJmp.cpp @@ -109,6 +109,9 @@ namespace { bool IsTransformableFunction(const std::string& Name); public: + static const int ID; // Pass identifcation, replacement for typeid + LowerSetJmp() : ModulePass((intptr_t)&ID) {} + void visitCallInst(CallInst& CI); void visitInvokeInst(InvokeInst& II); void visitReturnInst(ReturnInst& RI); @@ -118,6 +121,7 @@ namespace { bool doInitialization(Module& M); }; + const int LowerSetJmp::ID = 0; RegisterPass X("lowersetjmp", "Lower Set Jump"); } // end anonymous namespace diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp index 6040379d58e..ee37992d163 100644 --- a/lib/Transforms/IPO/PruneEH.cpp +++ b/lib/Transforms/IPO/PruneEH.cpp @@ -35,6 +35,9 @@ STATISTIC(NumUnreach, "Number of noreturn calls optimized"); namespace { struct VISIBILITY_HIDDEN PruneEH : public CallGraphSCCPass { + static const int ID; // Pass identifcation, replacement for typeid + PruneEH() : CallGraphSCCPass((intptr_t)&ID) {} + /// DoesNotUnwind - This set contains all of the functions which we have /// determined cannot unwind. std::set DoesNotUnwind; @@ -49,6 +52,8 @@ namespace { bool SimplifyFunction(Function *F); void DeleteBasicBlock(BasicBlock *BB); }; + + const int PruneEH::ID = 0; RegisterPass X("prune-eh", "Remove unused exception handling info"); } diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp index ce6db5624a0..f7f40377f0d 100644 --- a/lib/Transforms/IPO/RaiseAllocations.cpp +++ b/lib/Transforms/IPO/RaiseAllocations.cpp @@ -35,7 +35,9 @@ namespace { Function *MallocFunc; // Functions in the module we are processing Function *FreeFunc; // Initialized by doPassInitializationVirt public: - RaiseAllocations() : MallocFunc(0), FreeFunc(0) {} + static const int ID; // Pass identifcation, replacement for typeid + RaiseAllocations() + : ModulePass((intptr_t)&ID), MallocFunc(0), FreeFunc(0) {} // doPassInitialization - For the raise allocations pass, this finds a // declaration for malloc and free if they exist. @@ -47,6 +49,7 @@ namespace { bool runOnModule(Module &M); }; + const int RaiseAllocations::ID = 0; RegisterPass X("raiseallocs", "Raise allocations from calls to instructions"); } // end anonymous namespace diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp index 5900a0254fc..f5a8fee3877 100644 --- a/lib/Transforms/IPO/SimplifyLibCalls.cpp +++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp @@ -152,6 +152,9 @@ public: /// @brief A ModulePass for optimizing well-known function calls. class VISIBILITY_HIDDEN SimplifyLibCalls : public ModulePass { public: + static const int ID; // Pass identifcation, replacement for typeid + SimplifyLibCalls() : ModulePass((intptr_t)&ID) {} + /// We need some target data for accurate signature details that are /// target dependent. So we require target data in our AnalysisUsage. /// @brief Require TargetData from AnalysisUsage. @@ -373,6 +376,7 @@ private: TargetData *TD; ///< Cached TargetData }; +const int SimplifyLibCalls::ID = 0; // Register the pass RegisterPass X("simplify-libcalls", "Simplify well-known library calls"); diff --git a/lib/Transforms/IPO/StripDeadPrototypes.cpp b/lib/Transforms/IPO/StripDeadPrototypes.cpp index 7d03ae68abf..d1467f9b58b 100644 --- a/lib/Transforms/IPO/StripDeadPrototypes.cpp +++ b/lib/Transforms/IPO/StripDeadPrototypes.cpp @@ -27,9 +27,12 @@ namespace { /// @brief Pass to remove unused function declarations. class VISIBILITY_HIDDEN StripDeadPrototypesPass : public ModulePass { public: - StripDeadPrototypesPass() { } + static const int ID; // Pass identifcation, replacement for typeid + StripDeadPrototypesPass() : ModulePass((intptr_t)&ID) { } virtual bool runOnModule(Module &M); }; + +const int StripDeadPrototypesPass::ID = 0; RegisterPass X("strip-dead-prototypes", "Strip Unused Function Prototypes"); diff --git a/lib/Transforms/IPO/StripSymbols.cpp b/lib/Transforms/IPO/StripSymbols.cpp index 2a5e8309296..3330f7afaec 100644 --- a/lib/Transforms/IPO/StripSymbols.cpp +++ b/lib/Transforms/IPO/StripSymbols.cpp @@ -37,7 +37,9 @@ namespace { class VISIBILITY_HIDDEN StripSymbols : public ModulePass { bool OnlyDebugInfo; public: - StripSymbols(bool ODI = false) : OnlyDebugInfo(ODI) {} + static const int ID; // Pass identifcation, replacement for typeid + StripSymbols(bool ODI = false) + : ModulePass((intptr_t)&ID), OnlyDebugInfo(ODI) {} virtual bool runOnModule(Module &M); @@ -45,6 +47,8 @@ namespace { AU.setPreservesAll(); } }; + + const int StripSymbols::ID = 0; RegisterPass X("strip", "Strip all symbols from a module"); } diff --git a/lib/Transforms/Instrumentation/BlockProfiling.cpp b/lib/Transforms/Instrumentation/BlockProfiling.cpp index fb7268e57b9..a44899e1b91 100644 --- a/lib/Transforms/Instrumentation/BlockProfiling.cpp +++ b/lib/Transforms/Instrumentation/BlockProfiling.cpp @@ -32,9 +32,13 @@ using namespace llvm; namespace { class VISIBILITY_HIDDEN FunctionProfiler : public RSProfilers_std { + public: + static const int ID; bool runOnModule(Module &M); }; + const int FunctionProfiler::ID = 0; + RegisterPass X("insert-function-profiling", "Insert instrumentation for function profiling"); RegisterAnalysisGroup XG(X); @@ -79,8 +83,11 @@ bool FunctionProfiler::runOnModule(Module &M) { namespace { class BlockProfiler : public RSProfilers_std { bool runOnModule(Module &M); + public: + static const int ID; }; + const int BlockProfiler::ID = 0; RegisterPass Y("insert-block-profiling", "Insert instrumentation for block profiling"); RegisterAnalysisGroup YG(Y); diff --git a/lib/Transforms/Instrumentation/EdgeProfiling.cpp b/lib/Transforms/Instrumentation/EdgeProfiling.cpp index e45d2bfd151..ff7d4270ba4 100644 --- a/lib/Transforms/Instrumentation/EdgeProfiling.cpp +++ b/lib/Transforms/Instrumentation/EdgeProfiling.cpp @@ -32,8 +32,12 @@ using namespace llvm; namespace { class VISIBILITY_HIDDEN EdgeProfiler : public ModulePass { bool runOnModule(Module &M); + public: + static const int ID; // Pass identifcation, replacement for typeid + EdgeProfiler() : ModulePass((intptr_t)&ID) {} }; + const int EdgeProfiler::ID = 0; RegisterPass X("insert-edge-profiling", "Insert instrumentation for edge profiling"); } diff --git a/lib/Transforms/Instrumentation/RSProfiling.cpp b/lib/Transforms/Instrumentation/RSProfiling.cpp index f97b2bcd3e7..ad9a841cb0d 100644 --- a/lib/Transforms/Instrumentation/RSProfiling.cpp +++ b/lib/Transforms/Instrumentation/RSProfiling.cpp @@ -69,6 +69,7 @@ namespace { /// measuring framework overhead class VISIBILITY_HIDDEN NullProfilerRS : public RSProfilers { public: + static const int ID; // Pass identifcation, replacement for typeid bool isProfiling(Value* v) { return false; } @@ -80,7 +81,9 @@ namespace { } }; + const int RSProfilers::ID = 0; static RegisterAnalysisGroup A("Profiling passes"); + const int NullProfilerRS::ID = 0; static RegisterPass NP("insert-null-profiling-rs", "Measure profiling framework overhead"); static RegisterAnalysisGroup NPT(NP); @@ -138,6 +141,9 @@ namespace { /// ProfilerRS - Insert the random sampling framework struct VISIBILITY_HIDDEN ProfilerRS : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + ProfilerRS() : FunctionPass((intptr_t)&ID) {} + std::map TransCache; std::set ChoicePoints; Chooser* c; @@ -154,6 +160,7 @@ namespace { virtual void getAnalysisUsage(AnalysisUsage &AU) const; }; + const int ProfilerRS::ID = 0; RegisterPass X("insert-rs-profiling-framework", "Insert random sampling instrumentation framework"); } diff --git a/lib/Transforms/Instrumentation/RSProfiling.h b/lib/Transforms/Instrumentation/RSProfiling.h index 747773a87c5..3f7d92f17ab 100644 --- a/lib/Transforms/Instrumentation/RSProfiling.h +++ b/lib/Transforms/Instrumentation/RSProfiling.h @@ -17,6 +17,7 @@ namespace llvm { /// RSProfilers_std - a simple support class for profilers that handles most /// of the work of chaining and tracking inserted code. struct RSProfilers_std : public RSProfilers { + static const int ID; std::set profcode; // Lookup up values in profcode virtual bool isProfiling(Value* v); diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp index 3946f5707cd..75e9d2f61b5 100644 --- a/lib/Transforms/Scalar/ADCE.cpp +++ b/lib/Transforms/Scalar/ADCE.cpp @@ -52,6 +52,9 @@ class VISIBILITY_HIDDEN ADCE : public FunctionPass { // The public interface for this class // public: + static const int ID; // Pass identifcation, replacement for typeid + ADCE() : FunctionPass((intptr_t)&ID) {} + // Execute the Aggressive Dead Code Elimination Algorithm // virtual bool runOnFunction(Function &F) { @@ -104,6 +107,7 @@ private: } }; + const int ADCE::ID = 0; RegisterPass X("adce", "Aggressive Dead Code Elimination"); } // End of anonymous namespace diff --git a/lib/Transforms/Scalar/BasicBlockPlacement.cpp b/lib/Transforms/Scalar/BasicBlockPlacement.cpp index 14de1f1f475..a560d559bd9 100644 --- a/lib/Transforms/Scalar/BasicBlockPlacement.cpp +++ b/lib/Transforms/Scalar/BasicBlockPlacement.cpp @@ -41,6 +41,9 @@ STATISTIC(NumMoved, "Number of basic blocks moved"); namespace { struct VISIBILITY_HIDDEN BlockPlacement : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + BlockPlacement() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -70,6 +73,7 @@ namespace { void PlaceBlocks(BasicBlock *BB); }; + const int BlockPlacement::ID = 0; RegisterPass X("block-placement", "Profile Guided Basic Block Placement"); } diff --git a/lib/Transforms/Scalar/CodeGenPrepare.cpp b/lib/Transforms/Scalar/CodeGenPrepare.cpp index 7a3eac78c56..738db8027a8 100644 --- a/lib/Transforms/Scalar/CodeGenPrepare.cpp +++ b/lib/Transforms/Scalar/CodeGenPrepare.cpp @@ -39,7 +39,9 @@ namespace { /// transformation profitability. const TargetLowering *TLI; public: - CodeGenPrepare(const TargetLowering *tli = 0) : TLI(tli) {} + static const int ID; // Pass identifcation, replacement for typeid + CodeGenPrepare(const TargetLowering *tli = 0) : FunctionPass((intptr_t)&ID), + TLI(tli) {} bool runOnFunction(Function &F); private: @@ -52,6 +54,8 @@ namespace { DenseMap &SunkAddrs); }; } + +const int CodeGenPrepare::ID = 0; static RegisterPass X("codegenprepare", "Optimize for code generation"); diff --git a/lib/Transforms/Scalar/CondPropagate.cpp b/lib/Transforms/Scalar/CondPropagate.cpp index 90a4f3048fe..4f41b1badf6 100644 --- a/lib/Transforms/Scalar/CondPropagate.cpp +++ b/lib/Transforms/Scalar/CondPropagate.cpp @@ -31,6 +31,9 @@ STATISTIC(NumSwThread, "Number of CFG edges threaded through switches"); namespace { struct VISIBILITY_HIDDEN CondProp : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + CondProp() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -45,6 +48,8 @@ namespace { void SimplifyPredecessors(SwitchInst *SI); void RevectorBlockTo(BasicBlock *FromBB, BasicBlock *ToBB); }; + + const int CondProp::ID = 0; RegisterPass X("condprop", "Conditional Propagation"); } diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp index 226d1deb41b..32f5879911c 100644 --- a/lib/Transforms/Scalar/ConstantProp.cpp +++ b/lib/Transforms/Scalar/ConstantProp.cpp @@ -34,6 +34,9 @@ STATISTIC(NumInstKilled, "Number of instructions killed"); namespace { struct VISIBILITY_HIDDEN ConstantPropagation : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + ConstantPropagation() : FunctionPass((intptr_t)&ID) {} + bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -41,6 +44,7 @@ namespace { } }; + const int ConstantPropagation::ID = 0; RegisterPass X("constprop", "Simple constant propagation"); } diff --git a/lib/Transforms/Scalar/CorrelatedExprs.cpp b/lib/Transforms/Scalar/CorrelatedExprs.cpp index d42dd9a7e27..540f62c6747 100644 --- a/lib/Transforms/Scalar/CorrelatedExprs.cpp +++ b/lib/Transforms/Scalar/CorrelatedExprs.cpp @@ -225,6 +225,9 @@ namespace { std::map RegionInfoMap; ETForest *EF; public: + static const int ID; // Pass identifcation, replacement for typeid + CEE() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); // We don't modify the program, so we preserve all analyses @@ -284,6 +287,8 @@ namespace { bool SimplifyBasicBlock(BasicBlock &BB, const RegionInfo &RI); bool SimplifyInstruction(Instruction *Inst, const RegionInfo &RI); }; + + const int CEE::ID = 0; RegisterPass X("cee", "Correlated Expression Elimination"); } diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp index 998d87cf1b6..1bfa73d91ff 100644 --- a/lib/Transforms/Scalar/DCE.cpp +++ b/lib/Transforms/Scalar/DCE.cpp @@ -35,6 +35,8 @@ namespace { // DeadInstElimination pass implementation // struct VISIBILITY_HIDDEN DeadInstElimination : public BasicBlockPass { + static const int ID; // Pass identifcation, replacement for typeid + DeadInstElimination() : BasicBlockPass(intptr_t(&ID)) {} virtual bool runOnBasicBlock(BasicBlock &BB) { bool Changed = false; for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) @@ -51,6 +53,7 @@ namespace { } }; + const int DeadInstElimination::ID = 0; RegisterPass X("die", "Dead Instruction Elimination"); } @@ -64,6 +67,9 @@ namespace { // DeadCodeElimination pass implementation // struct DCE : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + DCE() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -71,6 +77,7 @@ namespace { } }; + const int DCE::ID = 0; RegisterPass Y("dce", "Dead Code Elimination"); } diff --git a/lib/Transforms/Scalar/DeadStoreElimination.cpp b/lib/Transforms/Scalar/DeadStoreElimination.cpp index 9ebb9b4974b..709d1689f8d 100644 --- a/lib/Transforms/Scalar/DeadStoreElimination.cpp +++ b/lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -34,6 +34,8 @@ STATISTIC(NumOther , "Number of other instrs removed"); namespace { struct VISIBILITY_HIDDEN DSE : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + DSE() : FunctionPass((intptr_t)&ID) {} virtual bool runOnFunction(Function &F) { bool Changed = false; @@ -56,6 +58,7 @@ namespace { AU.addPreserved(); } }; + const int DSE::ID = 0; RegisterPass X("dse", "Dead Store Elimination"); } diff --git a/lib/Transforms/Scalar/GCSE.cpp b/lib/Transforms/Scalar/GCSE.cpp index f4727d4e303..bf84c937ace 100644 --- a/lib/Transforms/Scalar/GCSE.cpp +++ b/lib/Transforms/Scalar/GCSE.cpp @@ -37,6 +37,9 @@ STATISTIC(NumArgsRepl , "Number of function arguments replaced " "with constant values"); namespace { struct VISIBILITY_HIDDEN GCSE : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + GCSE() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); private: @@ -51,6 +54,7 @@ namespace { } }; + const int GCSE::ID = 0; RegisterPass X("gcse", "Global Common Subexpression Elimination"); } diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index aad6cc9a5e8..313f811051f 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -68,7 +68,10 @@ namespace { ScalarEvolution *SE; bool Changed; public: - + + static const int ID; // Pass identifcation, replacement for typeid + IndVarSimplify() : LoopPass((intptr_t)&ID) {} + bool runOnLoop(Loop *L, LPPassManager &LPM); bool doInitialization(Loop *L, LPPassManager &LPM); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -91,6 +94,8 @@ namespace { void DeleteTriviallyDeadInstructions(std::set &Insts); }; + + const int IndVarSimplify::ID = 0; RegisterPass X("indvars", "Canonicalize Induction Variables"); } diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index b3496c34399..c1bc47d5439 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -76,6 +76,9 @@ namespace { TargetData *TD; bool MustPreserveLCSSA; public: + static const int ID; // Pass identifcation, replacement for typeid + InstCombiner() : FunctionPass((intptr_t)&ID) {} + /// AddToWorkList - Add the specified instruction to the worklist if it /// isn't already in it. void AddToWorkList(Instruction *I) { @@ -358,6 +361,7 @@ namespace { Value *EvaluateInDifferentType(Value *V, const Type *Ty, bool isSigned); }; + const int InstCombiner::ID = 0; RegisterPass X("instcombine", "Combine redundant instructions"); } diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp index f367973fddc..6a16243ebaf 100644 --- a/lib/Transforms/Scalar/LICM.cpp +++ b/lib/Transforms/Scalar/LICM.cpp @@ -63,6 +63,9 @@ namespace { cl::desc("Disable memory promotion in LICM pass")); struct VISIBILITY_HIDDEN LICM : public LoopPass { + static const int ID; // Pass identifcation, replacement for typeid + LICM() : LoopPass((intptr_t)&ID) {} + virtual bool runOnLoop(Loop *L, LPPassManager &LPM); /// This transformation requires natural loop information & requires that @@ -201,6 +204,7 @@ namespace { std::map &Val2AlMap); }; + const int LICM::ID = 0; RegisterPass X("licm", "Loop Invariant Code Motion"); } diff --git a/lib/Transforms/Scalar/LoopRotation.cpp b/lib/Transforms/Scalar/LoopRotation.cpp index b9db3f6f90c..8abd96eb06f 100644 --- a/lib/Transforms/Scalar/LoopRotation.cpp +++ b/lib/Transforms/Scalar/LoopRotation.cpp @@ -44,7 +44,9 @@ namespace { class VISIBILITY_HIDDEN LoopRotate : public LoopPass { public: - + static const int ID; // Pass ID, replacement for typeid + LoopRotate() : LoopPass((intptr_t)&ID) {} + // Rotate Loop L as many times as possible. Return true if // loop is rotated at least once. bool runOnLoop(Loop *L, LPPassManager &LPM); @@ -92,6 +94,7 @@ namespace { SmallVector LoopHeaderInfo; }; + const int LoopRotate::ID = 0; RegisterPass X ("loop-rotate", "Rotate Loops"); } diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 6bece9cfb7e..5f9562b6b3f 100644 --- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -143,7 +143,9 @@ namespace { const TargetLowering *TLI; public: - LoopStrengthReduce(const TargetLowering *tli = NULL) : TLI(tli) { + static const int ID; // Pass ID, replacement for typeid + LoopStrengthReduce(const TargetLowering *tli = NULL) : + LoopPass((intptr_t)&ID), TLI(tli) { } bool runOnLoop(Loop *L, LPPassManager &LPM); @@ -186,6 +188,7 @@ private: Loop *L, bool isOnlyStride); void DeleteTriviallyDeadInstructions(std::set &Insts); }; + const int LoopStrengthReduce::ID = 0; RegisterPass X("loop-reduce", "Loop Strength Reduction"); } diff --git a/lib/Transforms/Scalar/LoopUnroll.cpp b/lib/Transforms/Scalar/LoopUnroll.cpp index 63696025cbb..0cdef0f8a39 100644 --- a/lib/Transforms/Scalar/LoopUnroll.cpp +++ b/lib/Transforms/Scalar/LoopUnroll.cpp @@ -49,6 +49,9 @@ namespace { class VISIBILITY_HIDDEN LoopUnroll : public LoopPass { LoopInfo *LI; // The current loop information public: + static const int ID; // Pass ID, replacement for typeid + LoopUnroll() : LoopPass((intptr_t)&ID) {} + bool runOnLoop(Loop *L, LPPassManager &LPM); BasicBlock* FoldBlockIntoPredecessor(BasicBlock* BB); @@ -63,6 +66,7 @@ namespace { AU.addPreserved(); } }; + const int LoopUnroll::ID = 0; RegisterPass X("loop-unroll", "Unroll loops"); } diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp index 77dfb908fa7..ce459e708ad 100644 --- a/lib/Transforms/Scalar/LoopUnswitch.cpp +++ b/lib/Transforms/Scalar/LoopUnswitch.cpp @@ -69,6 +69,9 @@ namespace { SmallPtrSet UnswitchedVals; public: + static const int ID; // Pass ID, replacement for typeid + LoopUnswitch() : LoopPass((intptr_t)&ID) {} + bool runOnLoop(Loop *L, LPPassManager &LPM); /// This transformation requires natural loop information & requires that @@ -109,6 +112,7 @@ namespace { std::vector &Worklist); void RemoveLoopFromHierarchy(Loop *L); }; + const int LoopUnswitch::ID = 0; RegisterPass X("loop-unswitch", "Unswitch loops"); } diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp index c10849e297f..93e7e85ab3c 100644 --- a/lib/Transforms/Scalar/LowerGC.cpp +++ b/lib/Transforms/Scalar/LowerGC.cpp @@ -47,7 +47,9 @@ namespace { /// had zero roots. const Type *MainRootRecordType; public: - LowerGC() : GCRootInt(0), GCReadInt(0), GCWriteInt(0), + static const int ID; // Pass identifcation, replacement for typeid + LowerGC() : FunctionPass((intptr_t)&ID), + GCRootInt(0), GCReadInt(0), GCWriteInt(0), GCRead(0), GCWrite(0), RootChain(0), MainRootRecordType(0) {} virtual bool doInitialization(Module &M); virtual bool runOnFunction(Function &F); @@ -56,6 +58,7 @@ namespace { const StructType *getRootRecordType(unsigned NumRoots); }; + const int LowerGC::ID = 0; RegisterPass X("lowergc", "Lower GC intrinsics, for GCless code generators"); } diff --git a/lib/Transforms/Scalar/LowerPacked.cpp b/lib/Transforms/Scalar/LowerPacked.cpp index 10a5e60a861..11949dbc674 100644 --- a/lib/Transforms/Scalar/LowerPacked.cpp +++ b/lib/Transforms/Scalar/LowerPacked.cpp @@ -40,6 +40,9 @@ namespace { class VISIBILITY_HIDDEN LowerPacked : public FunctionPass, public InstVisitor { public: + static const int ID; // Pass identifcation, replacement for typeid + LowerPacked() : FunctionPass((intptr_t)&ID) {} + /// @brief Lowers packed operations to scalar operations. /// @param F The fuction to process virtual bool runOnFunction(Function &F); @@ -104,6 +107,7 @@ private: std::vector instrsToRemove; }; +const int LowerPacked::ID = 0; RegisterPass X("lower-packed", "lowers packed operations to operations on smaller packed datatypes"); diff --git a/lib/Transforms/Scalar/PredicateSimplifier.cpp b/lib/Transforms/Scalar/PredicateSimplifier.cpp index 289f9c96557..ce2741bdce6 100644 --- a/lib/Transforms/Scalar/PredicateSimplifier.cpp +++ b/lib/Transforms/Scalar/PredicateSimplifier.cpp @@ -1989,6 +1989,9 @@ namespace { std::vector WorkList; public: + static const int ID; // Pass identifcation, replacement for typeid + PredicateSimplifier() : FunctionPass((intptr_t)&ID) {} + bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -2374,6 +2377,7 @@ namespace { } } + const int PredicateSimplifier::ID = 0; RegisterPass X("predsimplify", "Predicate Simplifier"); } diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 8030a76eced..a07b0febebe 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -69,6 +69,9 @@ namespace { std::map ValueRankMap; bool MadeChange; public: + static const int ID; // Pass identifcation, replacement for typeid + Reassociate() : FunctionPass((intptr_t)&ID) {} + bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -89,6 +92,7 @@ namespace { void RemoveDeadBinaryOp(Value *V); }; + const int Reassociate::ID = 0; RegisterPass X("reassociate", "Reassociate expressions"); } diff --git a/lib/Transforms/Scalar/Reg2Mem.cpp b/lib/Transforms/Scalar/Reg2Mem.cpp index e013cedb0d1..6abe4dc39ef 100644 --- a/lib/Transforms/Scalar/Reg2Mem.cpp +++ b/lib/Transforms/Scalar/Reg2Mem.cpp @@ -33,6 +33,8 @@ STATISTIC(NumDemoted, "Number of registers demoted"); namespace { struct VISIBILITY_HIDDEN RegToMem : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + RegToMem() : FunctionPass((intptr_t)&ID) {} virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequiredID(BreakCriticalEdgesID); @@ -76,6 +78,7 @@ namespace { } }; + const int RegToMem::ID = 0; RegisterPass X("reg2mem", "Demote all values to stack slots"); } diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 16e7a8e269b..4ead2757b47 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -1334,6 +1334,9 @@ namespace { /// Sparse Conditional Constant Propagator. /// struct VISIBILITY_HIDDEN SCCP : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + SCCP() : FunctionPass((intptr_t)&ID) {} + // runOnFunction - Run the Sparse Conditional Constant Propagation // algorithm, and return true if the function was modified. // @@ -1344,6 +1347,7 @@ namespace { } }; + const int SCCP::ID = 0; RegisterPass X("sccp", "Sparse Conditional Constant Propagation"); } // end anonymous namespace @@ -1443,9 +1447,12 @@ namespace { /// Constant Propagation. /// struct VISIBILITY_HIDDEN IPSCCP : public ModulePass { + static const int ID; + IPSCCP() : ModulePass((intptr_t)&ID) {} bool runOnModule(Module &M); }; + const int IPSCCP::ID = 0; RegisterPass Y("ipsccp", "Interprocedural Sparse Conditional Constant Propagation"); } // end anonymous namespace diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index 71007d29fe3..da5488be762 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -47,6 +47,9 @@ STATISTIC(NumGlobals, "Number of allocas copied from constant global"); namespace { struct VISIBILITY_HIDDEN SROA : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + SROA() : FunctionPass((intptr_t)&ID) {} + bool runOnFunction(Function &F); bool performScalarRepl(Function &F); @@ -81,6 +84,7 @@ namespace { static Instruction *isOnlyCopiedFromConstantGlobal(AllocationInst *AI); }; + const int SROA::ID = 0; RegisterPass X("scalarrepl", "Scalar Replacement of Aggregates"); } diff --git a/lib/Transforms/Scalar/SimplifyCFG.cpp b/lib/Transforms/Scalar/SimplifyCFG.cpp index 872232fb3ed..4a4bcb6eac4 100644 --- a/lib/Transforms/Scalar/SimplifyCFG.cpp +++ b/lib/Transforms/Scalar/SimplifyCFG.cpp @@ -35,8 +35,12 @@ STATISTIC(NumSimpl, "Number of blocks simplified"); namespace { struct VISIBILITY_HIDDEN CFGSimplifyPass : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + CFGSimplifyPass() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); }; + const int CFGSimplifyPass::ID = 0; RegisterPass X("simplifycfg", "Simplify the CFG"); } diff --git a/lib/Transforms/Scalar/TailDuplication.cpp b/lib/Transforms/Scalar/TailDuplication.cpp index 398da0aa9b6..dcd57ce212f 100644 --- a/lib/Transforms/Scalar/TailDuplication.cpp +++ b/lib/Transforms/Scalar/TailDuplication.cpp @@ -42,10 +42,15 @@ namespace { cl::init(6), cl::Hidden); class VISIBILITY_HIDDEN TailDup : public FunctionPass { bool runOnFunction(Function &F); + public: + static const int ID; // Pass identifcation, replacement for typeid + TailDup() : FunctionPass((intptr_t)&ID) {} + private: inline bool shouldEliminateUnconditionalBranch(TerminatorInst *TI); inline void eliminateUnconditionalBranch(BranchInst *BI); }; + const int TailDup::ID = 0; RegisterPass X("tailduplicate", "Tail Duplication"); } diff --git a/lib/Transforms/Scalar/TailRecursionElimination.cpp b/lib/Transforms/Scalar/TailRecursionElimination.cpp index cd3b79aab6c..c75b93015ca 100644 --- a/lib/Transforms/Scalar/TailRecursionElimination.cpp +++ b/lib/Transforms/Scalar/TailRecursionElimination.cpp @@ -67,6 +67,9 @@ STATISTIC(NumAccumAdded, "Number of accumulators introduced"); namespace { struct VISIBILITY_HIDDEN TailCallElim : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + TailCallElim() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); private: @@ -77,6 +80,7 @@ namespace { bool CanMoveAboveCall(Instruction *I, CallInst *CI); Value *CanTransformAccumulatorRecursion(Instruction *I, CallInst *CI); }; + const int TailCallElim::ID = 0; RegisterPass X("tailcallelim", "Tail Call Elimination"); } diff --git a/lib/Transforms/Utils/BreakCriticalEdges.cpp b/lib/Transforms/Utils/BreakCriticalEdges.cpp index 7761e9361e7..561b71dd2c5 100644 --- a/lib/Transforms/Utils/BreakCriticalEdges.cpp +++ b/lib/Transforms/Utils/BreakCriticalEdges.cpp @@ -34,6 +34,9 @@ STATISTIC(NumBroken, "Number of blocks inserted"); namespace { struct VISIBILITY_HIDDEN BreakCriticalEdges : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + BreakCriticalEdges() : FunctionPass((intptr_t)&ID) {} + virtual bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -47,6 +50,7 @@ namespace { } }; + const int BreakCriticalEdges::ID = 0; RegisterPass X("break-crit-edges", "Break critical edges in CFG"); } diff --git a/lib/Transforms/Utils/LCSSA.cpp b/lib/Transforms/Utils/LCSSA.cpp index 0c223c53024..e46e35b3cad 100644 --- a/lib/Transforms/Utils/LCSSA.cpp +++ b/lib/Transforms/Utils/LCSSA.cpp @@ -47,6 +47,9 @@ STATISTIC(NumLCSSA, "Number of live out of a loop variables"); namespace { struct VISIBILITY_HIDDEN LCSSA : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + LCSSA() : FunctionPass((intptr_t)&ID) {} + // Cached analysis information for the current function. LoopInfo *LI; DominatorTree *DT; @@ -81,6 +84,7 @@ namespace { } }; + const int LCSSA::ID = 0; RegisterPass X("lcssa", "Loop-Closed SSA Form Pass"); } diff --git a/lib/Transforms/Utils/LoopSimplify.cpp b/lib/Transforms/Utils/LoopSimplify.cpp index d27bc8c7ad2..cea0bca939d 100644 --- a/lib/Transforms/Utils/LoopSimplify.cpp +++ b/lib/Transforms/Utils/LoopSimplify.cpp @@ -54,6 +54,9 @@ STATISTIC(NumNested , "Number of nested loops split out"); namespace { struct VISIBILITY_HIDDEN LoopSimplify : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + LoopSimplify() : FunctionPass((intptr_t)&ID) {} + // AA - If we have an alias analysis object to update, this is it, otherwise // this is null. AliasAnalysis *AA; @@ -89,6 +92,7 @@ namespace { std::vector &PredBlocks); }; + const int LoopSimplify::ID = 0; RegisterPass X("loopsimplify", "Canonicalize natural loops", true); } diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index cb2f88558ef..0ecc775c354 100644 --- a/lib/Transforms/Utils/LowerAllocations.cpp +++ b/lib/Transforms/Utils/LowerAllocations.cpp @@ -36,8 +36,10 @@ namespace { Constant *FreeFunc; // Initialized by doInitialization bool LowerMallocArgToInteger; public: + static const int ID; // Pass ID, replacement for typeid LowerAllocations(bool LowerToInt = false) - : MallocFunc(0), FreeFunc(0), LowerMallocArgToInteger(LowerToInt) {} + : BasicBlockPass((intptr_t)&ID), MallocFunc(0), FreeFunc(0), + LowerMallocArgToInteger(LowerToInt) {} virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); @@ -66,6 +68,7 @@ namespace { bool runOnBasicBlock(BasicBlock &BB); }; + const int LowerAllocations::ID = 0; RegisterPass X("lowerallocs", "Lower allocations from instructions to calls"); } diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp index e0332d28f72..3f8d06f31aa 100644 --- a/lib/Transforms/Utils/LowerInvoke.cpp +++ b/lib/Transforms/Utils/LowerInvoke.cpp @@ -75,7 +75,9 @@ namespace { const TargetLowering *TLI; public: - LowerInvoke(const TargetLowering *tli = NULL) : TLI(tli) { } + static const int ID; // Pass identifcation, replacement for typeid + LowerInvoke(const TargetLowering *tli = NULL) : FunctionPass((intptr_t)&ID), + TLI(tli) { } bool doInitialization(Module &M); bool runOnFunction(Function &F); @@ -97,6 +99,7 @@ namespace { bool insertExpensiveEHSupport(Function &F); }; + const int LowerInvoke::ID = 0; RegisterPass X("lowerinvoke", "Lower invoke and unwind, for unwindless code generators"); } diff --git a/lib/Transforms/Utils/LowerSelect.cpp b/lib/Transforms/Utils/LowerSelect.cpp index 120c3b19c71..fda26c9e1f1 100644 --- a/lib/Transforms/Utils/LowerSelect.cpp +++ b/lib/Transforms/Utils/LowerSelect.cpp @@ -33,7 +33,9 @@ namespace { class VISIBILITY_HIDDEN LowerSelect : public FunctionPass { bool OnlyFP; // Only lower FP select instructions? public: - LowerSelect(bool onlyfp = false) : OnlyFP(onlyfp) {} + static const int ID; // Pass identifcation, replacement for typeid + LowerSelect(bool onlyfp = false) : FunctionPass((intptr_t)&ID), + OnlyFP(onlyfp) {} virtual void getAnalysisUsage(AnalysisUsage &AU) const { // This certainly destroys the CFG. @@ -48,6 +50,7 @@ namespace { bool runOnFunction(Function &F); }; + const int LowerSelect::ID = 0; RegisterPass X("lowerselect", "Lower select instructions to branches"); } diff --git a/lib/Transforms/Utils/LowerSwitch.cpp b/lib/Transforms/Utils/LowerSwitch.cpp index 61fa85c5eb6..482ada9b6a2 100644 --- a/lib/Transforms/Utils/LowerSwitch.cpp +++ b/lib/Transforms/Utils/LowerSwitch.cpp @@ -30,6 +30,9 @@ namespace { /// modifies the CFG! class VISIBILITY_HIDDEN LowerSwitch : public FunctionPass { public: + static const int ID; // Pass identifcation, replacement for typeid + LowerSwitch() : FunctionPass((intptr_t) &ID) {} + virtual bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -75,6 +78,7 @@ namespace { } }; + const int LowerSwitch::ID = 0; RegisterPass X("lowerswitch", "Lower SwitchInst's to branches"); } diff --git a/lib/Transforms/Utils/Mem2Reg.cpp b/lib/Transforms/Utils/Mem2Reg.cpp index 7d69fd25001..37bc318545c 100644 --- a/lib/Transforms/Utils/Mem2Reg.cpp +++ b/lib/Transforms/Utils/Mem2Reg.cpp @@ -27,6 +27,9 @@ STATISTIC(NumPromoted, "Number of alloca's promoted"); namespace { struct VISIBILITY_HIDDEN PromotePass : public FunctionPass { + static const int ID; // Pass identifcation, replacement for typeid + PromotePass() : FunctionPass((intptr_t)&ID) {} + // runOnFunction - To run this pass, first we calculate the alloca // instructions that are safe for promotion, then we promote each one. // @@ -47,6 +50,7 @@ namespace { } }; + const int PromotePass::ID = 0; RegisterPass X("mem2reg", "Promote Memory to Register"); } // end of anonymous namespace diff --git a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp index 07512b94f48..f7dd1139caa 100644 --- a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp +++ b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp @@ -22,6 +22,7 @@ #include "llvm/Type.h" using namespace llvm; +const int UnifyFunctionExitNodes::ID = 0; static RegisterPass X("mergereturn", "Unify function exit nodes"); diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index 3a065b0cdfe..53828f618e9 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -135,8 +135,10 @@ public: } // end namespace llvm +const int PrintModulePass::ID = 0; static RegisterPass X("printm", "Print module to stderr"); +const int PrintFunctionPass::ID = 0; static RegisterPass Y("print","Print function to stderr"); diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp index 9ed4c44fa5e..905b56ee63e 100644 --- a/lib/VMCore/Dominators.cpp +++ b/lib/VMCore/Dominators.cpp @@ -58,6 +58,7 @@ static std::ostream &operator<<(std::ostream &o, // //===----------------------------------------------------------------------===// +const int DominatorTree::ID = 0; static RegisterPass E("domtree", "Dominator Tree Construction", true); @@ -353,6 +354,7 @@ bool DominatorTree::runOnFunction(Function &F) { // DominanceFrontier Implementation //===----------------------------------------------------------------------===// +const int DominanceFrontier::ID = 0; static RegisterPass G("domfrontier", "Dominance Frontier Construction", true); @@ -833,6 +835,7 @@ void ETNode::assignDFSNumber(int num) { // ETForest implementation //===----------------------------------------------------------------------===// +const int ETForest::ID = 0; static RegisterPass D("etforest", "ET Forest Construction", true); diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index e6b31b302a9..2f581c51abf 100644 --- a/lib/VMCore/Pass.cpp +++ b/lib/VMCore/Pass.cpp @@ -133,7 +133,7 @@ namespace { class PassRegistrar { /// PassInfoMap - Keep track of the passinfo object for each registered llvm /// pass. - std::map PassInfoMap; + std::map PassInfoMap; /// AnalysisGroupInfo - Keep track of information for each analysis group. struct AnalysisGroupInfo { @@ -147,19 +147,19 @@ class PassRegistrar { public: - const PassInfo *GetPassInfo(const std::type_info &TI) const { - std::map::const_iterator I = PassInfoMap.find(TI); + const PassInfo *GetPassInfo(intptr_t TI) const { + std::map::const_iterator I = PassInfoMap.find(TI); return I != PassInfoMap.end() ? I->second : 0; } void RegisterPass(PassInfo &PI) { bool Inserted = - PassInfoMap.insert(std::make_pair(TypeInfo(PI.getTypeInfo()),&PI)).second; + PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; assert(Inserted && "Pass registered multiple times!"); } void UnregisterPass(PassInfo &PI) { - std::map::iterator I = + std::map::iterator I = PassInfoMap.find(PI.getTypeInfo()); assert(I != PassInfoMap.end() && "Pass registered but not in map!"); @@ -168,7 +168,7 @@ public: } void EnumerateWith(PassRegistrationListener *L) { - for (std::map::const_iterator I = PassInfoMap.begin(), + for (std::map::const_iterator I = PassInfoMap.begin(), E = PassInfoMap.end(); I != E; ++I) L->passEnumerate(I->second); } @@ -210,11 +210,10 @@ static PassRegistrar *getPassRegistrar() { // getPassInfo - Return the PassInfo data structure that corresponds to this // pass... const PassInfo *Pass::getPassInfo() const { - if (PassInfoCache) return PassInfoCache; - return lookupPassInfo(typeid(*this)); + return lookupPassInfo(PassID); } -const PassInfo *Pass::lookupPassInfo(const std::type_info &TI) { +const PassInfo *Pass::lookupPassInfo(intptr_t TI) { return getPassRegistrar()->GetPassInfo(TI); } @@ -238,12 +237,12 @@ void RegisterPassBase::unregisterPass() { // RegisterAGBase implementation // -RegisterAGBase::RegisterAGBase(const std::type_info &Interface, - const std::type_info *Pass, bool isDefault) - : RegisterPassBase(Interface), +RegisterAGBase::RegisterAGBase(intptr_t InterfaceID, + intptr_t PassID, bool isDefault) + : RegisterPassBase(InterfaceID), ImplementationInfo(0), isDefaultImplementation(isDefault) { - InterfaceInfo = const_cast(Pass::lookupPassInfo(Interface)); + InterfaceInfo = const_cast(Pass::lookupPassInfo(InterfaceID)); if (InterfaceInfo == 0) { // First reference to Interface, register it now. registerPass(); @@ -252,8 +251,8 @@ RegisterAGBase::RegisterAGBase(const std::type_info &Interface, assert(PIObj.isAnalysisGroup() && "Trying to join an analysis group that is a normal pass!"); - if (Pass) { - ImplementationInfo = Pass::lookupPassInfo(*Pass); + if (PassID) { + ImplementationInfo = Pass::lookupPassInfo(PassID); assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp index 6fadc842006..694827bc5be 100644 --- a/lib/VMCore/PassManager.cpp +++ b/lib/VMCore/PassManager.cpp @@ -63,7 +63,9 @@ class VISIBILITY_HIDDEN BBPassManager : public PMDataManager, public FunctionPass { public: - BBPassManager(int Depth) : PMDataManager(Depth) { } + static const int ID; + BBPassManager(int Depth) + : PMDataManager(Depth), FunctionPass((intptr_t)&ID) {} /// Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the function, and if so, return true. @@ -104,6 +106,7 @@ public: } }; +const int BBPassManager::ID = 0; } namespace llvm { @@ -116,9 +119,10 @@ class FunctionPassManagerImpl : public Pass, public PMDataManager, public PMTopLevelManager { public: - - FunctionPassManagerImpl(int Depth) : PMDataManager(Depth), - PMTopLevelManager(TLM_Function) { } + static const int ID; + FunctionPassManagerImpl(int Depth) : + Pass((intptr_t)&ID), PMDataManager(Depth), + PMTopLevelManager(TLM_Function) { } /// add - Add a pass to the queue of passes to run. This passes ownership of /// the Pass to the PassManager. When the PassManager is destroyed, the pass @@ -167,9 +171,9 @@ public: FPPassManager *FP = static_cast(PassManagers[N]); return FP; } - }; +const int FunctionPassManagerImpl::ID = 0; //===----------------------------------------------------------------------===// // MPPassManager // @@ -179,7 +183,8 @@ public: class MPPassManager : public Pass, public PMDataManager { public: - MPPassManager(int Depth) : PMDataManager(Depth) { } + static const int ID; + MPPassManager(int Depth) : Pass((intptr_t)&ID), PMDataManager(Depth) { } // Delete on the fly managers. virtual ~MPPassManager() { @@ -242,17 +247,19 @@ public: std::map OnTheFlyManagers; }; +const int MPPassManager::ID = 0; //===----------------------------------------------------------------------===// // PassManagerImpl // + /// PassManagerImpl manages MPPassManagers class PassManagerImpl : public Pass, public PMDataManager, public PMTopLevelManager { public: - - PassManagerImpl(int Depth) : PMDataManager(Depth), + static const int ID; + PassManagerImpl(int Depth) : Pass((intptr_t)&ID), PMDataManager(Depth), PMTopLevelManager(TLM_Pass) { } /// add - Add a pass to the queue of passes to run. This passes ownership of @@ -297,6 +304,7 @@ public: }; +const int PassManagerImpl::ID = 0; } // End of llvm namespace namespace { @@ -1100,6 +1108,7 @@ bool FunctionPassManagerImpl::run(Function &F) { //===----------------------------------------------------------------------===// // FPPassManager implementation +const int FPPassManager::ID = 0; /// Print passes managed by this manager void FPPassManager::dumpPassStructure(unsigned Offset) { llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n"; diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 8e632e2f8da..94027f858fe 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -69,6 +69,7 @@ namespace { // Anonymous namespace for class struct VISIBILITY_HIDDEN Verifier : public FunctionPass, InstVisitor { + static const int ID; // Pass ID, replacement for typeid bool Broken; // Is this module found to be broken? bool RealPass; // Are we not being run by a PassManager? VerifierFailureAction action; @@ -84,18 +85,22 @@ namespace { // Anonymous namespace for class SmallPtrSet InstsInThisBlock; Verifier() - : Broken(false), RealPass(true), action(AbortProcessAction), - EF(0), msgs( std::ios::app | std::ios::out ) {} + : FunctionPass((intptr_t)&ID), + Broken(false), RealPass(true), action(AbortProcessAction), + EF(0), msgs( std::ios::app | std::ios::out ) {} Verifier( VerifierFailureAction ctn ) - : Broken(false), RealPass(true), action(ctn), EF(0), - msgs( std::ios::app | std::ios::out ) {} + : FunctionPass((intptr_t)&ID), + Broken(false), RealPass(true), action(ctn), EF(0), + msgs( std::ios::app | std::ios::out ) {} Verifier(bool AB ) - : Broken(false), RealPass(true), - action( AB ? AbortProcessAction : PrintMessageAction), EF(0), - msgs( std::ios::app | std::ios::out ) {} + : FunctionPass((intptr_t)&ID), + Broken(false), RealPass(true), + action( AB ? AbortProcessAction : PrintMessageAction), EF(0), + msgs( std::ios::app | std::ios::out ) {} Verifier(ETForest &ef) - : Broken(false), RealPass(false), action(PrintMessageAction), - EF(&ef), msgs( std::ios::app | std::ios::out ) {} + : FunctionPass((intptr_t)&ID), + Broken(false), RealPass(false), action(PrintMessageAction), + EF(&ef), msgs( std::ios::app | std::ios::out ) {} bool doInitialization(Module &M) { @@ -261,6 +266,7 @@ namespace { // Anonymous namespace for class } }; + const int Verifier::ID = 0; RegisterPass X("verify", "Module Verifier"); } // End anonymous namespace diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp index 1ff06f88b1c..e4eb32f07a5 100644 --- a/tools/bugpoint/ExtractFunction.cpp +++ b/tools/bugpoint/ExtractFunction.cpp @@ -305,7 +305,11 @@ namespace { /// BlocksToNotExtract list. class BlockExtractorPass : public ModulePass { bool runOnModule(Module &M); + public: + static const int ID; // Pass ID, replacement for typeid + BlockExtractorPass() : ModulePass((intptr_t)&ID) {} }; + const int BlockExtractorPass::ID = 0; RegisterPass XX("extract-bbs", "Extract Basic Blocks From Module (for bugpoint use)"); } diff --git a/tools/bugpoint/TestPasses.cpp b/tools/bugpoint/TestPasses.cpp index 5147a907070..a3fc1496125 100644 --- a/tools/bugpoint/TestPasses.cpp +++ b/tools/bugpoint/TestPasses.cpp @@ -25,6 +25,10 @@ namespace { /// CrashOnCalls - This pass is used to test bugpoint. It intentionally /// crashes on any call instructions. class CrashOnCalls : public BasicBlockPass { + public: + static const int ID; // Pass ID, replacement for typeid + CrashOnCalls() : BasicBlockPass((intptr_t)&ID) {} + private: virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); } @@ -38,6 +42,7 @@ namespace { } }; + const int CrashOnCalls::ID = 0; RegisterPass X("bugpoint-crashcalls", "BugPoint Test Pass - Intentionally crash on CallInsts"); @@ -47,6 +52,10 @@ namespace { /// DeleteCalls - This pass is used to test bugpoint. It intentionally /// deletes some call instructions, "misoptimizing" the program. class DeleteCalls : public BasicBlockPass { + public: + static const int ID; // Pass ID, replacement for typeid + DeleteCalls() : BasicBlockPass((intptr_t)&ID) {} + private: bool runOnBasicBlock(BasicBlock &BB) { for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) if (CallInst *CI = dyn_cast(I)) { @@ -58,7 +67,8 @@ namespace { return false; } }; - + + const int DeleteCalls::ID = 0; RegisterPass Y("bugpoint-deletecalls", "BugPoint Test Pass - Intentionally 'misoptimize' CallInsts"); diff --git a/tools/opt/AnalysisWrappers.cpp b/tools/opt/AnalysisWrappers.cpp index 3223b820303..a13695daef4 100644 --- a/tools/opt/AnalysisWrappers.cpp +++ b/tools/opt/AnalysisWrappers.cpp @@ -30,6 +30,8 @@ namespace { /// useful when looking for standard library functions we should constant fold /// or handle in alias analyses. struct ExternalFunctionsPassedConstants : public ModulePass { + static const int ID; // Pass ID, replacement for typeid + ExternalFunctionsPassedConstants() : ModulePass((intptr_t)&ID) {} virtual bool runOnModule(Module &M) { for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) if (I->isDeclaration()) { @@ -61,10 +63,14 @@ namespace { } }; + const int ExternalFunctionsPassedConstants::ID = 0; RegisterPass P1("externalfnconstants", "Print external fn callsites passed constants"); struct CallGraphPrinter : public ModulePass { + static const int ID; // Pass ID, replacement for typeid + CallGraphPrinter() : ModulePass((intptr_t)&ID) {} + virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); AU.addRequiredTransitive(); @@ -76,6 +82,7 @@ namespace { } }; + const int CallGraphPrinter::ID = 0; RegisterPass P2("callgraph", "Print a call graph"); } diff --git a/tools/opt/GraphPrinters.cpp b/tools/opt/GraphPrinters.cpp index 5e8a859443c..cb0b6643ae3 100644 --- a/tools/opt/GraphPrinters.cpp +++ b/tools/opt/GraphPrinters.cpp @@ -60,6 +60,9 @@ namespace llvm { namespace { struct CallGraphPrinter : public ModulePass { + static const int ID; // Pass ID, replacement for typeid + CallGraphPrinter() : ModulePass((intptr_t)&ID) {} + virtual bool runOnModule(Module &M) { WriteGraphToFile(std::cerr, "callgraph", &getAnalysis()); return false; @@ -74,6 +77,7 @@ namespace { } }; + const int CallGraphPrinter::ID = 0; RegisterPass P2("print-callgraph", "Print Call Graph to 'dot' file"); } diff --git a/tools/opt/PrintSCC.cpp b/tools/opt/PrintSCC.cpp index 904442d11f8..689307ca66b 100644 --- a/tools/opt/PrintSCC.cpp +++ b/tools/opt/PrintSCC.cpp @@ -35,6 +35,8 @@ using namespace llvm; namespace { struct CFGSCC : public FunctionPass { + static const int ID; // Pass identification, replacement for typeid + CFGSCC() : FunctionPass((intptr_t)&ID) {} bool runOnFunction(Function& func); void print(std::ostream &O, const Module* = 0) const { } @@ -45,6 +47,9 @@ namespace { }; struct CallGraphSCC : public ModulePass { + static const int ID; // Pass identification, replacement for typeid + CallGraphSCC() : ModulePass((intptr_t)&ID) {} + // run - Print out SCCs in the call graph for the specified module. bool runOnModule(Module &M); @@ -57,9 +62,11 @@ namespace { } }; + const int CFGSCC::ID = 0; RegisterPass Y("cfgscc", "Print SCCs of each function CFG"); + const int CallGraphSCC::ID = 0; RegisterPass Z("callscc", "Print SCCs of the Call Graph"); } diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index d30d412f05e..680bb5f49f1 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -98,8 +98,10 @@ AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization")); namespace { struct ModulePassPrinter : public ModulePass { + static const int ID; const PassInfo *PassToPrint; - ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {} + ModulePassPrinter(const PassInfo *PI) : ModulePass((intptr_t)&ID), + PassToPrint(PI) {} virtual bool runOnModule(Module &M) { if (!Quiet) { @@ -119,12 +121,15 @@ struct ModulePassPrinter : public ModulePass { } }; +const int ModulePassPrinter::ID = 0; struct FunctionPassPrinter : public FunctionPass { const PassInfo *PassToPrint; - FunctionPassPrinter(const PassInfo *PI) : PassToPrint(PI) {} + static const int ID; + FunctionPassPrinter(const PassInfo *PI) : FunctionPass((intptr_t)&ID), + PassToPrint(PI) {} virtual bool runOnFunction(Function &F) { - if (!Quiet) { + if (!Quiet) { cout << "Printing analysis '" << PassToPrint->getPassName() << "' for function '" << F.getName() << "':\n"; } @@ -141,9 +146,12 @@ struct FunctionPassPrinter : public FunctionPass { } }; +const int FunctionPassPrinter::ID = 0; struct BasicBlockPassPrinter : public BasicBlockPass { const PassInfo *PassToPrint; - BasicBlockPassPrinter(const PassInfo *PI) : PassToPrint(PI) {} + static const int ID; + BasicBlockPassPrinter(const PassInfo *PI) + : BasicBlockPass((intptr_t)&ID), PassToPrint(PI) {} virtual bool runOnBasicBlock(BasicBlock &BB) { if (!Quiet) { @@ -164,6 +172,7 @@ struct BasicBlockPassPrinter : public BasicBlockPass { } }; +const int BasicBlockPassPrinter::ID = 0; inline void addPass(PassManager &PM, Pass *P) { // Add the pass to the pass manager... PM.add(P); -- 2.34.1