X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassManager.h;h=b6a8186a4e809b2049b01bfcdf143cd9778bfb65;hb=f3e397eb17327423b3f8fff5eac8547c85efddb1;hp=1f9bf92ccd50c5f2f90b625cffcf89dc69d5ffcc;hpb=a9bf6f329e48504c4e38a892adb5e8e97e6f86fd;p=oota-llvm.git diff --git a/include/llvm/PassManager.h b/include/llvm/PassManager.h index 1f9bf92ccd5..b6a8186a4e8 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,34 @@ #define LLVM_PASSMANAGER_H #include "llvm/Pass.h" -#include +#include "llvm/Support/CBindingWrapping.h" 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,201 +53,55 @@ 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; - -class FunctionPassManager { - FunctionPassManagerT *PM; // This is a straightforward Pimpl class - ModuleProvider *MP; -public: - 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); - - /// 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(); -}; - -/// 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; + /// PassManagerImpl_New is the actual class. PassManager is just the + /// wraper to publish simple pass manager interface + PassManagerImpl *PM; }; -/// 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 PassManagerAnalysisHelper { - +/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers. +class FunctionPassManager : public PassManagerBase { 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); - -private: - // Collection of pass that are managed by this manager - std::vector PassVector; -}; + /// FunctionPassManager ctor - This initializes the pass manager. It needs, + /// but does not take ownership of, the specified Module. + explicit FunctionPassManager(Module *M); + ~FunctionPassManager(); -/// 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 PassManagerAnalysisHelper { -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.) + /// there is no need to delete the pass. /// 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); + void add(Pass *P); - /// Execute all of the passes scheduled for execution. Keep + /// 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 runOnModule(Module &M); - -private: - // Collection of pass that are manged by this manager - std::vector PassVector; - - // Active Pass Managers - BasicBlockPassManager_New *activeBBPassManager; -}; - -/// ModulePassManager_New manages ModulePasses and function pass managers. -/// It batches all Module passes passes and function pass managers together and -/// sequence them to process one module. -class ModulePassManager_New : public Pass, - public PassManagerAnalysisHelper { - -public: - ModulePassManager_New() { activeFunctionPassManager = NULL; } - - /// Add a pass into a passmanager queue. - bool addPass(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 runOnModule(Module &M); - -private: - // Collection of pass that are managed by this manager - std::vector PassVector; - - // Active Pass Manager - FunctionPassManager_New *activeFunctionPassManager; -}; - -/// PassManager_New manages ModulePassManagers -class PassManager_New : public Pass, - public PassManagerAnalysisHelper { + /// + bool run(Function &F); -public: + /// 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: - - /// Add a pass into a passmanager queue. This is used by schedulePasses - bool addPass(Pass *p); - - /// Schedule all passes collected in pass queue using add(). Add all the - /// schedule passes into various manager's queue using addPass(). - void schedulePasses(); - - // Collection of pass managers - std::vector PassManagers; - - // Collection of pass that are not yet scheduled - std::vector PassVector; - - // Active Pass Manager - ModulePassManager_New *activeManager; + FunctionPassManagerImpl *FPM; + Module *M; }; +// Create wrappers for C Binding types (see CBindingWrapping.h). +DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef) + } // End llvm namespace #endif