X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassManager.h;h=a6703fd5867a88457d4a91b8dc67e22ec6126903;hb=fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154;hp=53dfa6bab0f30c707a17665372eebfc3c63b3d2d;hpb=448d27cd795dc273249f123444509403f4fa4fac;p=oota-llvm.git diff --git a/include/llvm/PassManager.h b/include/llvm/PassManager.h index 53dfa6bab0f..a6703fd5867 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,7 +18,6 @@ #define LLVM_PASSMANAGER_H #include "llvm/Pass.h" -#include namespace llvm { @@ -26,13 +25,28 @@ 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,107 +54,57 @@ 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: -class FunctionPassManager { - FunctionPassManagerT *PM; // This is a straightforward Pimpl class - ModuleProvider *MP; + /// PassManagerImpl_New is the actual class. PassManager is just the + /// wraper to publish simple pass manager interface + PassManagerImpl *PM; +}; + +/// 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 provider. + explicit FunctionPassManager(ModuleProvider *P); ~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. (TODO delete passes.) + /// 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. + /// doInitialization - Run all of the initializers for the function passes. + /// + bool doInitialization(); + + /// doFinalization - Run all of the finalizers for the function passes. /// bool doFinalization(); -}; - -/// BasicBlockpassManager_New manages BasicBlockPass. It batches all the -/// pass together and sequence them to process one basic block before -/// processing next basic block. -class BasicBlockPassManager_New: public Pass { - -public: - BasicBlockPassManager_New() { } - - /// Add a pass into a passmanager queue. - bool addPass(Pass *p); - /// 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 runOnFunction(Function &F); + /// getModuleProvider - Return the module provider that this passmanager is + /// currently using. This is the module provider that it uses when a function + /// is optimized that is non-resident in the module. + ModuleProvider *getModuleProvider() const { return MP; } + void setModuleProvider(ModuleProvider *NewMP) { MP = NewMP; } private: - // Collection of pass that are not yet scheduled - std::vector PassVector; -}; - -/// FunctionPassManager_New manages FunctionPasses and BasicBlockPassManagers. -/// It batches all function passes and basic block pass managers together and -/// sequence them to process one function at a time before processing next -/// function. -class FunctionPassManager_New:public Pass { -public: - FunctionPassManager_New(ModuleProvider *P) { /* TODO */ } - FunctionPassManager_New() { - activeBBPassManager = NULL; - } - ~FunctionPassManager_New() { /* TODO */ }; - - /// add - Add a pass to the queue of passes to run. This passes - /// 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. (TODO delete passes.) - /// This implies that all passes MUST be allocated with 'new'. - void add(Pass *P) { /* TODO*/ } - - /// Add pass into the pass manager queue. - bool addPass(Pass *P); - - /// 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 runOnModule(Module &M); - -private: - // Collection of pass that are not yet scheduled - std::vector PassVector; - - // Active Pass Managers - BasicBlockPassManager_New *activeBBPassManager; + FunctionPassManagerImpl *FPM; + ModuleProvider *MP; }; } // End llvm namespace