include/llvm/PassManager.h

   1 //===- llvm/PassManager.h - Container for Passes ----------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the PassManager class.  This class is used to hold,
  11 // maintain, and optimize execution of Passes.  The PassManager class ensures
  12 // that analysis results are available before a pass runs, and that Pass's are
  13 // destroyed when the PassManager is destroyed.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_PASSMANAGER_H
  18 #define LLVM_PASSMANAGER_H
  19
  20 #include "llvm/Pass.h"
  21 #include <vector>
  22
  23 namespace llvm {
  24
  25 class Pass;
  26 class ModulePass;
  27 class Module;
  28 class ModuleProvider;
  29 class ModulePassManager;
  30 class FunctionPassManagerT;
  31 class BasicBlockPassManager;
  32
  33 class PassManager {
  34   ModulePassManager *PM;    // This is a straightforward Pimpl class
  35 public:
  36   PassManager();
  37   ~PassManager();
  38
  39   /// add - Add a pass to the queue of passes to run.  This passes ownership of
  40   /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
  41   /// will be destroyed as well, so there is no need to delete the pass.  This
  42   /// implies that all passes MUST be allocated with 'new'.
  43   ///
  44   void add(Pass *P);
  45
  46   /// run - Execute all of the passes scheduled for execution.  Keep track of
  47   /// whether any of the passes modifies the module, and if so, return true.
  48   ///
  49   bool run(Module &M);
  50 };
  51
  52 class FunctionPass;
  53 class ImmutablePass;
  54 class Function;
  55
  56 class FunctionPassManager {
  57   FunctionPassManagerT *PM;    // This is a straightforward Pimpl class
  58   ModuleProvider *MP;
  59 public:
  60   FunctionPassManager(ModuleProvider *P);
  61   ~FunctionPassManager();
  62
  63   /// add - Add a pass to the queue of passes to run.  This passes
  64   /// ownership of the FunctionPass to the PassManager.  When the
  65   /// PassManager is destroyed, the pass will be destroyed as well, so
  66   /// there is no need to delete the pass.  This implies that all
  67   /// passes MUST be allocated with 'new'.
  68   ///
  69   void add(FunctionPass *P);
  70
  71   /// add - ImmutablePasses are not FunctionPasses, so we have a
  72   /// special hack to get them into a FunctionPassManager.
  73   ///
  74   void add(ImmutablePass *IP);
  75
  76   /// doInitialization - Run all of the initializers for the function passes.
  77   ///
  78   bool doInitialization();
  79
  80   /// run - Execute all of the passes scheduled for execution.  Keep
  81   /// track of whether any of the passes modifies the function, and if
  82   /// so, return true.
  83   ///
  84   bool run(Function &F);
  85
  86   /// doFinalization - Run all of the initializers for the function passes.
  87   ///
  88   bool doFinalization();
  89 };
  90
  91 class ModulePassManager_New;
  92 class PassManagerImpl_New;
  93
  94 /// PassManagerAnalysisHelper helps pass manager analysis required by
  95 /// the managed passes. It provides methods to add/remove analysis
  96 /// available and query if certain analysis is available or not.
  97 class PassManagerAnalysisHelper {
  98
  99 public:
 100
 101   /// Return true IFF pass P's required analysis set does not required new
 102   /// manager.
 103   bool manageablePass(Pass *P);
 104
 105   /// Return true IFF AnalysisID AID is currently available.
 106   bool analysisCurrentlyAvailable(AnalysisID AID);
 107
 108   /// Augment RequiredSet by adding analysis required by pass P.
 109   void noteDownRequiredAnalysis(Pass *P);
 110
 111   /// Remove AnalysisID from the RequiredSet
 112   void removeAnalysis(AnalysisID AID);
 113
 114   /// Remove Analysis that is not preserved by the pass
 115   void removeNotPreservedAnalysis(Pass *P);
 116
 117   /// Remove dead passes
 118   void removeDeadPasses() { /* TODO : Implement */ }
 119
 120 private:
 121    // Required set of analysis for the passes managed by this manager
 122   std::vector<AnalysisID> RequiredSet;
 123 };
 124
 125 /// PassManager_New manages ModulePassManagers
 126 class PassManager_New : public Pass,
 127                         public PassManagerAnalysisHelper {
 128
 129 public:
 130
 131   PassManager_New();
 132
 133   /// add - Add a pass to the queue of passes to run.  This passes ownership of
 134   /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
 135   /// will be destroyed as well, so there is no need to delete the pass.  This
 136   /// implies that all passes MUST be allocated with 'new'.
 137   void add(Pass *P);
 138
 139   /// run - Execute all of the passes scheduled for execution.  Keep track of
 140   /// whether any of the passes modifies the module, and if so, return true.
 141   bool run(Module &M);
 142
 143 private:
 144
 145   /// PassManagerImpl_New is the actual class. PassManager_New is just the
 146   /// wraper to publish simple pass manager interface
 147   PassManagerImpl_New *PM;
 148
 149 };
 150
 151 } // End llvm namespace
 152
 153 #endif