X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassManager.h;h=2a191b339931a80b222fb7d35fbb1208e7b81193;hb=7b96c4919a33cd13fad2fd99c85e60cac51838e2;hp=23c30862106ed4c47c8e4f35f4861ee248054905;hpb=37a84c7d8bda439082b883e33be6ab88b4cce236;p=oota-llvm.git diff --git a/include/llvm/PassManager.h b/include/llvm/PassManager.h index 23c30862106..2a191b33993 100644 --- a/include/llvm/PassManager.h +++ b/include/llvm/PassManager.h @@ -2,178 +2,38 @@ // // 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. // //===----------------------------------------------------------------------===// // -// This file defines the PassManager class. This class is used to hold, -// maintain, and optimize execution of Passes. The PassManager class ensures -// that analysis results are available before a pass runs, and that Pass's are -// destroyed when the PassManager is destroyed. +// This is a legacy redirect header for the old PassManager. It is intended to +// be used by clients that have not been converted to be aware of the new pass +// management infrastructure being built for LLVM, which is every client +// initially. Eventually this header (and the legacy management layer) will go +// away, but we want to minimize changes to out-of-tree users of LLVM in the +// interim. +// +// Note that this header *must not* be included into the same file as the new +// pass management infrastructure is included. Things will break spectacularly. +// If you are starting that conversion, you should switch to explicitly +// including LegacyPassManager.h and using the legacy namespace. // //===----------------------------------------------------------------------===// #ifndef LLVM_PASSMANAGER_H #define LLVM_PASSMANAGER_H -#include "llvm/Pass.h" -#include +#include "llvm/IR/LegacyPassManager.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 -public: - 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); -}; - -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(); -}; - -class ModulePassManager_New; -class PassManagerImpl_New; -class FunctionPassManagerImpl_New; - -/// CommonPassManagerImpl 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 CommonPassManagerImpl : public Pass{ - -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 CommonPassManagerImpl { - -public: - - PassManager_New(); - - /// 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 - /// wraper to publish simple pass manager interface - PassManagerImpl_New *PM; - -}; - -/// FunctionPassManager_New manages FunctionPasses and BasicBlockPassManagers. -class FunctionPassManager_New : public CommonPassManagerImpl { -public: - FunctionPassManager_New(ModuleProvider *P) { /* TODO */ } - FunctionPassManager_New(); - ~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); - - /// 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: - - FunctionPassManagerImpl_New *FPM; - -}; - +// Pull these into the llvm namespace so that existing code that expects it +// there can find it. +using legacy::PassManagerBase; +using legacy::PassManager; +using legacy::FunctionPassManager; -} // End llvm namespace +} #endif