X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassManager.h;h=c8b5dcaf0f2dcc303d6c0658d804666765425795;hb=9a376a8003c486054ea4d7c2465cb90b501c9893;hp=f71d94a1dfe1dec5282592c31207e9b1c64b570f;hpb=c63592b19ecd54a1318a19d87b5c0bd85f172a4f;p=oota-llvm.git diff --git a/include/llvm/PassManager.h b/include/llvm/PassManager.h index f71d94a1dfe..c8b5dcaf0f2 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,118 +18,35 @@ #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: - 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); + virtual void add(Pass *P) = 0; }; -class FunctionPass; -class ImmutablePass; -class Function; - -class FunctionPassManager { - FunctionPassManagerT *PM; // This is a straightforward Pimpl class - ModuleProvider *MP; +/// PassManager manages ModulePassManagers +class PassManager : public PassManagerBase { 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(); -}; - -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 { - -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 @@ -142,20 +59,22 @@ public: bool run(Module &M); private: + /// addImpl - Add a pass to the queue of passes to run, without + /// checking whether to add a printer pass. + void addImpl(Pass *P); - /// 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 @@ -164,18 +83,29 @@ public: /// 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); - -private: + /// + bool run(Function &F); + + /// doInitialization - Run all of the initializers for the function passes. + /// + bool doInitialization(); + + /// doFinalization - Run all of the finalizers for the function passes. + /// + bool doFinalization(); - FunctionPassManagerImpl_New *FPM; +private: + /// addImpl - Add a pass to the queue of passes to run, without + /// checking whether to add a printer pass. + void addImpl(Pass *P); + FunctionPassManagerImpl *FPM; + Module *M; }; - } // End llvm namespace #endif