X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassManager.h;h=ce5fda79f9c7f9c73c1301d63854ea2e0c1af9a9;hb=b09c146b116359616f6cbd4c8b3328607e00ff42;hp=927ea9f785b8b2e5a6dc18d618df554e5b829a1c;hpb=5a39b2e8067450839a1a041a26e2f9d8dd07f40a;p=oota-llvm.git diff --git a/include/llvm/PassManager.h b/include/llvm/PassManager.h index 927ea9f785b..ce5fda79f9c 100644 --- a/include/llvm/PassManager.h +++ b/include/llvm/PassManager.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -18,21 +18,33 @@ #define LLVM_PASSMANAGER_H #include "llvm/Pass.h" -#include namespace llvm { class Pass; -class ModulePass; class Module; -class ModuleProvider; -class ModulePassManager; -class FunctionPassManagerT; -class BasicBlockPassManager; -class PassManager { - ModulePassManager *PM; // This is a straightforward Pimpl class +class PassManagerImpl; +class FunctionPassManagerImpl; + +/// PassManagerBase - An abstract interface to allow code to add passes to +/// a pass manager without having to hard-code what kind of pass manager +/// it is. +class PassManagerBase { public: + virtual ~PassManagerBase(); + + /// 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 + /// will be destroyed as well, so there is no need to delete the pass. This + /// implies that all passes MUST be allocated with 'new'. + virtual void add(Pass *P) = 0; +}; + +/// PassManager manages ModulePassManagers +class PassManager : public PassManagerBase { +public: + PassManager(); ~PassManager(); @@ -40,112 +52,50 @@ public: /// the Pass to the PassManager. When the PassManager is destroyed, the pass /// will be destroyed as well, so there is no need to delete the pass. This /// implies that all passes MUST be allocated with 'new'. - /// void add(Pass *P); /// 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 run(Module &M); -}; -class FunctionPass; -class ImmutablePass; -class Function; +private: + /// PassManagerImpl_New is the actual class. PassManager is just the + /// wraper to publish simple pass manager interface + PassManagerImpl *PM; +}; -class FunctionPassManager { - FunctionPassManagerT *PM; // This is a straightforward Pimpl class - ModuleProvider *MP; +/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers. +class FunctionPassManager : public PassManagerBase { public: - FunctionPassManager(ModuleProvider *P); + /// FunctionPassManager ctor - This initializes the pass manager. It needs, + /// but does not take ownership of, the specified Module. + explicit FunctionPassManager(Module *M); ~FunctionPassManager(); /// add - Add a pass to the queue of passes to run. This passes - /// ownership of the FunctionPass to the PassManager. When the - /// PassManager is destroyed, the pass will be destroyed as well, so - /// there is no need to delete the pass. This implies that all - /// passes MUST be allocated with 'new'. - /// - void add(FunctionPass *P); - - /// add - ImmutablePasses are not FunctionPasses, so we have a - /// special hack to get them into a FunctionPassManager. - /// - void add(ImmutablePass *IP); + /// ownership of the Pass to the PassManager. When the + /// PassManager_X is destroyed, the pass will be destroyed as well, so + /// there is no need to delete the pass. + /// This implies that all passes MUST be allocated with 'new'. + void add(Pass *P); - /// doInitialization - Run all of the initializers for the function passes. - /// - bool doInitialization(); - /// run - Execute all of the passes scheduled for execution. Keep /// track of whether any of the passes modifies the function, and if /// so, return true. /// bool run(Function &F); - - /// doFinalization - Run all of the initializers for the function passes. - /// - bool doFinalization(); -}; -class ModulePassManager_New; -class PassManagerImpl_New; - -/// PassManagerAnalysisHelper helps pass manager analysis required by -/// the managed passes. It provides methods to add/remove analysis -/// available and query if certain analysis is available or not. -class PassManagerAnalysisHelper { - -public: - - /// Return true IFF pass P's required analysis set does not required new - /// manager. - bool manageablePass(Pass *P); - - /// Return true IFF AnalysisID AID is currently available. - bool analysisCurrentlyAvailable(AnalysisID AID); - - /// Augment RequiredSet by adding analysis required by pass P. - void noteDownRequiredAnalysis(Pass *P); - - /// Remove AnalysisID from the RequiredSet - void removeAnalysis(AnalysisID AID); - - /// Remove Analysis that is not preserved by the pass - void removeNotPreservedAnalysis(Pass *P); - - /// Remove dead passes - void removeDeadPasses() { /* TODO : Implement */ } - -private: - // Required set of analysis for the passes managed by this manager - std::vector RequiredSet; -}; - -/// PassManager_New manages ModulePassManagers -class PassManager_New : public Pass, - public PassManagerAnalysisHelper { - -public: - - PassManager_New(); + /// doInitialization - Run all of the initializers for the function passes. + /// + bool doInitialization(); - /// 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 - /// will be destroyed as well, so there is no need to delete the pass. This - /// implies that all passes MUST be allocated with 'new'. - void add(Pass *P); - - /// 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 run(Module &M); + /// doFinalization - Run all of the finalizers for the function passes. + /// + bool doFinalization(); private: - - /// PassManagerImpl_New is the actual class. PassManager_New is just the - /// wraper to publish simple pass manager interface - PassManagerImpl_New *PM; - + FunctionPassManagerImpl *FPM; + Module *M; }; } // End llvm namespace