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 /// BasicBlockpassManager_New manages BasicBlockPass. It batches all the
  92 /// pass together and sequence them to process one basic block before
  93 /// processing next basic block.
  94 class BasicBlockPassManager_New: public Pass {
  95
  96 public:
  97   BasicBlockPassManager_New() { }
  98
  99   /// Add a pass into a passmanager queue.
 100   bool addPass(Pass *p);
 101
 102   /// Execute all of the passes scheduled for execution.  Keep track of
 103   /// whether any of the passes modifies the function, and if so, return true.
 104   bool runOnFunction(Function &F);
 105
 106 private:
 107   // Collection of pass that are not yet scheduled
 108   std::vector<Pass *> PassVector;
 109 };
 110
 111 /// FunctionPassManager_New manages FunctionPasses and BasicBlockPassManagers.
 112 /// It batches all function passes and basic block pass managers together and
 113 /// sequence them to process one function at a time before processing next
 114 /// function.
 115 class FunctionPassManager_New:public Pass {
 116 public:
 117   FunctionPassManager_New(ModuleProvider *P) { /* TODO */ }
 118   FunctionPassManager_New() {
 119     activeBBPassManager = NULL;
 120   }
 121   ~FunctionPassManager_New() { /* TODO */ };
 122
 123   /// add - Add a pass to the queue of passes to run.  This passes
 124   /// ownership of the Pass to the PassManager.  When the
 125   /// PassManager_X is destroyed, the pass will be destroyed as well, so
 126   /// there is no need to delete the pass. (TODO delete passes.)
 127   /// This implies that all passes MUST be allocated with 'new'.
 128   void add(Pass *P) { /* TODO*/  }
 129
 130   /// Add pass into the pass manager queue.
 131   bool addPass(Pass *P);
 132
 133   /// Execute all of the passes scheduled for execution.  Keep
 134   /// track of whether any of the passes modifies the function, and if
 135   /// so, return true.
 136   bool runOnModule(Module &M);
 137
 138 private:
 139   // Collection of pass that are not yet scheduled
 140   std::vector<Pass *> PassVector;
 141
 142   // Active Pass Managers
 143   BasicBlockPassManager_New *activeBBPassManager;
 144 };
 145
 146 /// FunctionPassManager_New manages FunctionPasses.
 147 /// It batches all Module passes  passes and function pass managers together and
 148 /// sequence them to process one module.
 149 class ModulePassManager_New: public Pass {
 150
 151 public:
 152   ModulePassManager_New() { activeFunctionPassManager = NULL; }
 153
 154   /// Add a pass into a passmanager queue.
 155   bool addPass(Pass *p);
 156
 157   /// run - Execute all of the passes scheduled for execution.  Keep track of
 158   /// whether any of the passes modifies the module, and if so, return true.
 159   bool runOnModule(Module &M);
 160
 161 private:
 162   // Collection of pass that are not yet scheduled
 163   std::vector<Pass *> PassVector;
 164
 165   // Active Pass Manager
 166   FunctionPassManager_New *activeFunctionPassManager;
 167 };
 168
 169 } // End llvm namespace
 170
 171 #endif