lib/VMCore/PassManager.cpp

   1 //===- PassManager.cpp - LLVM Pass Infrastructure Implementation ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Devang Patel and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the LLVM Pass Manager infrastructure.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14
  15 #include "llvm/PassManager.h"
  16 #include "llvm/Module.h"
  17
  18 using namespace llvm;
  19
  20 namespace llvm {
  21
  22 /// BasicBlockPassManager_New manages BasicBlockPass. It batches all the
  23 /// pass together and sequence them to process one basic block before
  24 /// processing next basic block.
  25 class BasicBlockPassManager_New : public CommonPassManagerImpl {
  26
  27 public:
  28   BasicBlockPassManager_New() { }
  29
  30   /// Add a pass into a passmanager queue.
  31   bool addPass(Pass *p);
  32
  33   /// Execute all of the passes scheduled for execution.  Keep track of
  34   /// whether any of the passes modifies the function, and if so, return true.
  35   bool runOnFunction(Function &F);
  36
  37 private:
  38   // Collection of pass that are managed by this manager
  39   std::vector<Pass *> PassVector;
  40 };
  41
  42 /// FunctionPassManagerImpl_New manages FunctionPasses and BasicBlockPassManagers.
  43 /// It batches all function passes and basic block pass managers together and
  44 /// sequence them to process one function at a time before processing next
  45 /// function.
  46 class FunctionPassManagerImpl_New : public CommonPassManagerImpl {
  47 public:
  48   FunctionPassManagerImpl_New(ModuleProvider *P) { /* TODO */ }
  49   FunctionPassManagerImpl_New() {
  50     activeBBPassManager = NULL;
  51   }
  52   ~FunctionPassManagerImpl_New() { /* TODO */ };
  53
  54   /// add - Add a pass to the queue of passes to run.  This passes
  55   /// ownership of the Pass to the PassManager.  When the
  56   /// PassManager_X is destroyed, the pass will be destroyed as well, so
  57   /// there is no need to delete the pass. (TODO delete passes.)
  58   /// This implies that all passes MUST be allocated with 'new'.
  59   void add(Pass *P) { /* TODO*/  }
  60
  61   /// Add pass into the pass manager queue.
  62   bool addPass(Pass *P);
  63
  64   /// Execute all of the passes scheduled for execution.  Keep
  65   /// track of whether any of the passes modifies the function, and if
  66   /// so, return true.
  67   bool runOnModule(Module &M);
  68
  69 private:
  70   // Collection of pass that are manged by this manager
  71   std::vector<Pass *> PassVector;
  72
  73   // Active Pass Managers
  74   BasicBlockPassManager_New *activeBBPassManager;
  75 };
  76
  77 /// ModulePassManager_New manages ModulePasses and function pass managers.
  78 /// It batches all Module passes  passes and function pass managers together and
  79 /// sequence them to process one module.
  80 class ModulePassManager_New : public CommonPassManagerImpl {
  81
  82 public:
  83   ModulePassManager_New() { activeFunctionPassManager = NULL; }
  84
  85   /// Add a pass into a passmanager queue.
  86   bool addPass(Pass *p);
  87
  88   /// run - Execute all of the passes scheduled for execution.  Keep track of
  89   /// whether any of the passes modifies the module, and if so, return true.
  90   bool runOnModule(Module &M);
  91
  92 private:
  93   // Collection of pass that are managed by this manager
  94   std::vector<Pass *> PassVector;
  95
  96   // Active Pass Manager
  97   FunctionPassManagerImpl_New *activeFunctionPassManager;
  98 };
  99
 100 /// PassManager_New manages ModulePassManagers
 101 class PassManagerImpl_New : public CommonPassManagerImpl {
 102
 103 public:
 104
 105   /// add - Add a pass to the queue of passes to run.  This passes ownership of
 106   /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
 107   /// will be destroyed as well, so there is no need to delete the pass.  This
 108   /// implies that all passes MUST be allocated with 'new'.
 109   void add(Pass *P);
 110
 111   /// run - Execute all of the passes scheduled for execution.  Keep track of
 112   /// whether any of the passes modifies the module, and if so, return true.
 113   bool run(Module &M);
 114
 115 private:
 116
 117   /// Add a pass into a passmanager queue. This is used by schedulePasses
 118   bool addPass(Pass *p);
 119
 120   /// Schedule all passes collected in pass queue using add(). Add all the
 121   /// schedule passes into various manager's queue using addPass().
 122   void schedulePasses();
 123
 124   // Collection of pass managers
 125   std::vector<ModulePassManager_New *> PassManagers;
 126
 127   // Collection of pass that are not yet scheduled
 128   std::vector<Pass *> PassVector;
 129
 130   // Active Pass Manager
 131   ModulePassManager_New *activeManager;
 132 };
 133
 134 } // End of llvm namespace
 135
 136 // CommonPassManagerImpl implementation
 137
 138 /// Return true IFF pass P's required analysis set does not required new
 139 /// manager.
 140 bool CommonPassManagerImpl::manageablePass(Pass *P) {
 141
 142   AnalysisUsage AnUsage;
 143   P->getAnalysisUsage(AnUsage);
 144
 145   // If this pass is not preserving information that is required by the other
 146   // passes managed by this manager then use new manager
 147   if (!AnUsage.getPreservesAll()) {
 148     const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet();
 149     for (std::vector<AnalysisID>::iterator I = RequiredAnalysis.begin(),
 150            E = RequiredAnalysis.end(); I != E; ++I) {
 151       if (std::find(PreservedSet.begin(), PreservedSet.end(), *I) ==
 152           PreservedSet.end())
 153         // This analysis is not preserved. Need new manager.
 154         return false;
 155     }
 156   }
 157   return true;
 158 }
 159
 160 /// Return true IFF AnalysisID AID is currently available.
 161 bool CommonPassManagerImpl::analysisCurrentlyAvailable(AnalysisID AID) {
 162
 163   // TODO
 164   return false;
 165 }
 166
 167 /// Augment RequiredSet by adding analysis required by pass P.
 168 void CommonPassManagerImpl::noteDownRequiredAnalysis(Pass *P) {
 169   AnalysisUsage AnUsage;
 170   P->getAnalysisUsage(AnUsage);
 171   const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet();
 172
 173   // FIXME: What about duplicates ?
 174   RequiredAnalysis.insert(RequiredAnalysis.end(), RequiredSet.begin(), RequiredSet.end());
 175 }
 176
 177 /// Remove AnalysisID from the RequiredSet
 178 void CommonPassManagerImpl::removeAnalysis(AnalysisID AID) {
 179
 180   // TODO
 181 }
 182
 183 /// Remove Analyss not preserved by Pass P
 184 void CommonPassManagerImpl::removeNotPreservedAnalysis(Pass *P) {
 185
 186   // TODO
 187 }
 188
 189 /// BasicBlockPassManager implementation
 190
 191 /// Add pass P into PassVector and return true. If this pass is not
 192 /// manageable by this manager then return false.
 193 bool
 194 BasicBlockPassManager_New::addPass(Pass *P) {
 195
 196   BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
 197   if (!BP)
 198     return false;
 199
 200   // If this pass does not preserve anlysis that is used by other passes
 201   // managed by this manager than it is not a suiable pass for this manager.
 202   if (!manageablePass(P))
 203     return false;
 204
 205   // Take a note of analysis required by this pass.
 206   noteDownRequiredAnalysis(P);
 207
 208   // Add pass
 209   PassVector.push_back(BP);
 210   return true;
 211 }
 212
 213 /// Execute all of the passes scheduled for execution by invoking
 214 /// runOnBasicBlock method.  Keep track of whether any of the passes modifies
 215 /// the function, and if so, return true.
 216 bool
 217 BasicBlockPassManager_New::runOnFunction(Function &F) {
 218
 219   bool Changed = false;
 220   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
 221     for (std::vector<Pass *>::iterator itr = PassVector.begin(),
 222            e = PassVector.end(); itr != e; ++itr) {
 223       Pass *P = *itr;
 224       BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
 225       Changed |= BP->runOnBasicBlock(*I);
 226     }
 227   return Changed;
 228 }
 229
 230 // FunctionPassManager_New implementation
 231 /// Create new Function pass manager
 232 FunctionPassManager_New::FunctionPassManager_New() {
 233   FPM = new FunctionPassManagerImpl_New();
 234 }
 235
 236 /// add - Add a pass to the queue of passes to run.  This passes
 237 /// ownership of the Pass to the PassManager.  When the
 238 /// PassManager_X is destroyed, the pass will be destroyed as well, so
 239 /// there is no need to delete the pass. (TODO delete passes.)
 240 /// This implies that all passes MUST be allocated with 'new'.
 241 void
 242 FunctionPassManager_New::add(Pass *P) {
 243   FPM->add(P);
 244 }
 245
 246 /// Execute all of the passes scheduled for execution.  Keep
 247 /// track of whether any of the passes modifies the function, and if
 248 /// so, return true.
 249 bool
 250 FunctionPassManager_New::runOnModule(Module &M) {
 251   return FPM->runOnModule(M);
 252 }
 253
 254 // FunctionPassManagerImpl_New implementation
 255
 256 // FunctionPassManager
 257
 258 /// Add pass P into the pass manager queue. If P is a BasicBlockPass then
 259 /// either use it into active basic block pass manager or create new basic
 260 /// block pass manager to handle pass P.
 261 bool
 262 FunctionPassManagerImpl_New::addPass(Pass *P) {
 263
 264   // If P is a BasicBlockPass then use BasicBlockPassManager_New.
 265   if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) {
 266
 267     if (!activeBBPassManager
 268         || !activeBBPassManager->addPass(BP)) {
 269
 270       activeBBPassManager = new BasicBlockPassManager_New();
 271
 272       PassVector.push_back(activeBBPassManager);
 273       if (!activeBBPassManager->addPass(BP))
 274         assert(0 && "Unable to add Pass");
 275     }
 276     return true;
 277   }
 278
 279   FunctionPass *FP = dynamic_cast<FunctionPass *>(P);
 280   if (!FP)
 281     return false;
 282
 283   // If this pass does not preserve anlysis that is used by other passes
 284   // managed by this manager than it is not a suiable pass for this manager.
 285   if (!manageablePass(P))
 286     return false;
 287
 288   // Take a note of analysis required by this pass.
 289   noteDownRequiredAnalysis(P);
 290
 291   PassVector.push_back(FP);
 292   activeBBPassManager = NULL;
 293   return true;
 294 }
 295
 296 /// Execute all of the passes scheduled for execution by invoking
 297 /// runOnFunction method.  Keep track of whether any of the passes modifies
 298 /// the function, and if so, return true.
 299 bool
 300 FunctionPassManagerImpl_New::runOnModule(Module &M) {
 301
 302   bool Changed = false;
 303   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
 304     for (std::vector<Pass *>::iterator itr = PassVector.begin(),
 305            e = PassVector.end(); itr != e; ++itr) {
 306       Pass *P = *itr;
 307       FunctionPass *FP = dynamic_cast<FunctionPass*>(P);
 308       Changed |= FP->runOnFunction(*I);
 309     }
 310   return Changed;
 311 }
 312
 313
 314 // ModulePassManager implementation
 315
 316 /// Add P into pass vector if it is manageble. If P is a FunctionPass
 317 /// then use FunctionPassManagerImpl_New to manage it. Return false if P
 318 /// is not manageable by this manager.
 319 bool
 320 ModulePassManager_New::addPass(Pass *P) {
 321
 322   // If P is FunctionPass then use function pass maanager.
 323   if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) {
 324
 325     activeFunctionPassManager = NULL;
 326
 327     if (!activeFunctionPassManager
 328         || !activeFunctionPassManager->addPass(P)) {
 329
 330       activeFunctionPassManager = new FunctionPassManagerImpl_New();
 331
 332       PassVector.push_back(activeFunctionPassManager);
 333       if (!activeFunctionPassManager->addPass(FP))
 334         assert(0 && "Unable to add pass");
 335     }
 336     return true;
 337   }
 338
 339   ModulePass *MP = dynamic_cast<ModulePass *>(P);
 340   if (!MP)
 341     return false;
 342
 343   // If this pass does not preserve anlysis that is used by other passes
 344   // managed by this manager than it is not a suiable pass for this manager.
 345   if (!manageablePass(P))
 346     return false;
 347
 348   // Take a note of analysis required by this pass.
 349   noteDownRequiredAnalysis(P);
 350
 351   PassVector.push_back(MP);
 352   activeFunctionPassManager = NULL;
 353   return true;
 354 }
 355
 356
 357 /// Execute all of the passes scheduled for execution by invoking
 358 /// runOnModule method.  Keep track of whether any of the passes modifies
 359 /// the module, and if so, return true.
 360 bool
 361 ModulePassManager_New::runOnModule(Module &M) {
 362   bool Changed = false;
 363   for (std::vector<Pass *>::iterator itr = PassVector.begin(),
 364          e = PassVector.end(); itr != e; ++itr) {
 365     Pass *P = *itr;
 366     ModulePass *MP = dynamic_cast<ModulePass*>(P);
 367     Changed |= MP->runOnModule(M);
 368   }
 369   return Changed;
 370 }
 371
 372 /// Schedule all passes from the queue by adding them in their
 373 /// respective manager's queue.
 374 void
 375 PassManagerImpl_New::schedulePasses() {
 376   /* TODO */
 377 }
 378
 379 /// Add pass P to the queue of passes to run.
 380 void
 381 PassManagerImpl_New::add(Pass *P) {
 382   /* TODO */
 383 }
 384
 385 // PassManager_New implementation
 386 /// Add P into active pass manager or use new module pass manager to
 387 /// manage it.
 388 bool
 389 PassManagerImpl_New::addPass(Pass *P) {
 390
 391   if (!activeManager || !activeManager->addPass(P)) {
 392     activeManager = new ModulePassManager_New();
 393     PassManagers.push_back(activeManager);
 394   }
 395
 396   return activeManager->addPass(P);
 397 }
 398
 399 /// run - Execute all of the passes scheduled for execution.  Keep track of
 400 /// whether any of the passes modifies the module, and if so, return true.
 401 bool
 402 PassManagerImpl_New::run(Module &M) {
 403
 404   schedulePasses();
 405   bool Changed = false;
 406   for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(),
 407          e = PassManagers.end(); itr != e; ++itr) {
 408     ModulePassManager_New *pm = *itr;
 409     Changed |= pm->runOnModule(M);
 410   }
 411   return Changed;
 412 }
 413
 414 /// Create new pass manager
 415 PassManager_New::PassManager_New() {
 416   PM = new PassManagerImpl_New();
 417 }
 418
 419 /// add - Add a pass to the queue of passes to run.  This passes ownership of
 420 /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
 421 /// will be destroyed as well, so there is no need to delete the pass.  This
 422 /// implies that all passes MUST be allocated with 'new'.
 423 void
 424 PassManager_New::add(Pass *P) {
 425   PM->add(P);
 426 }
 427
 428 /// run - Execute all of the passes scheduled for execution.  Keep track of
 429 /// whether any of the passes modifies the module, and if so, return true.
 430 bool
 431 PassManager_New::run(Module &M) {
 432   return PM->run(M);
 433 }
 434