X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassManager.h;h=b6a8186a4e809b2049b01bfcdf143cd9778bfb65;hb=2c46deb1d07f4588ee70059cdd4c7145f81bc8e8;hp=f71d94a1dfe1dec5282592c31207e9b1c64b570f;hpb=c63592b19ecd54a1318a19d87b5c0bd85f172a4f;p=oota-llvm.git diff --git a/include/llvm/PassManager.h b/include/llvm/PassManager.h index f71d94a1dfe..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,163 +18,89 @@ #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: - PassManager(); - ~PassManager(); + 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'. - /// - 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(); + virtual void add(Pass *P) = 0; }; -class ModulePassManager_New; -class PassManagerImpl_New; -class FunctionPassManagerImpl_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 { - +/// PassManager manages ModulePassManagers +class PassManager : public PassManagerBase { public: - PassManager_New(); + PassManager(); + ~PassManager(); /// 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); private: - - /// PassManagerImpl_New is the actual class. PassManager_New is just the + /// PassManagerImpl_New is the actual class. PassManager is just the /// wraper to publish simple pass manager interface - PassManagerImpl_New *PM; - + PassManagerImpl *PM; }; -/// FunctionPassManager_New manages FunctionPasses and BasicBlockPassManagers. -class FunctionPassManager_New : public Pass, - public PassManagerAnalysisHelper { +/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers. +class FunctionPassManager : public PassManagerBase { public: - FunctionPassManager_New(ModuleProvider *P) { /* TODO */ } - FunctionPassManager_New(); - ~FunctionPassManager_New() { /* TODO */ }; - + /// 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 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); - /// 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); + /// + bool run(Function &F); -private: - - FunctionPassManagerImpl_New *FPM; + /// doInitialization - Run all of the initializers for the function passes. + /// + bool doInitialization(); + /// doFinalization - Run all of the finalizers for the function passes. + /// + bool doFinalization(); + +private: + FunctionPassManagerImpl *FPM; + Module *M; }; +// Create wrappers for C Binding types (see CBindingWrapping.h). +DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef) } // End llvm namespace