lib/IR/PassManager.cpp

   1 //===- PassManager.h - Infrastructure for managing & running IR passes ----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/IR/PassManager.h"
  11 #include "llvm/ADT/STLExtras.h"
  12
  13 using namespace llvm;
  14
  15 void ModulePassManager::run(Module *M) {
  16   for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx)
  17     if (Passes[Idx]->run(M))
  18       if (AM)
  19         AM->invalidateAll(M);
  20 }
  21
  22 void ModuleAnalysisManager::invalidateAll(Module *M) {
  23   // FIXME: This is a total hack based on the fact that erasure doesn't
  24   // invalidate iteration for DenseMap.
  25   for (ModuleAnalysisResultMapT::iterator I = ModuleAnalysisResults.begin(),
  26                                           E = ModuleAnalysisResults.end();
  27        I != E; ++I)
  28     if (I->second->invalidate(M))
  29       ModuleAnalysisResults.erase(I);
  30 }
  31
  32 const detail::AnalysisResultConcept<Module> &
  33 ModuleAnalysisManager::getResultImpl(void *PassID, Module *M) {
  34   ModuleAnalysisResultMapT::iterator RI;
  35   bool Inserted;
  36   llvm::tie(RI, Inserted) = ModuleAnalysisResults.insert(std::make_pair(
  37       PassID, polymorphic_ptr<detail::AnalysisResultConcept<Module> >()));
  38
  39   if (Inserted) {
  40     // We don't have a cached result for this result. Look up the pass and run
  41     // it to produce a result, which we then add to the cache.
  42     ModuleAnalysisPassMapT::const_iterator PI =
  43         ModuleAnalysisPasses.find(PassID);
  44     assert(PI != ModuleAnalysisPasses.end() &&
  45            "Analysis passes must be registered prior to being queried!");
  46     RI->second = PI->second->run(M);
  47   }
  48
  49   return *RI->second;
  50 }
  51
  52 void ModuleAnalysisManager::invalidateImpl(void *PassID, Module *M) {
  53   ModuleAnalysisResults.erase(PassID);
  54 }
  55
  56 bool FunctionPassManager::run(Function *F) {
  57   bool Changed = false;
  58   for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx)
  59     if (Passes[Idx]->run(F)) {
  60       Changed = true;
  61       if (AM)
  62         AM->invalidateAll(F);
  63     }
  64   return Changed;
  65 }
  66
  67 void FunctionAnalysisManager::invalidateAll(Function *F) {
  68   // Clear all the invalidated results associated specifically with this
  69   // function.
  70   SmallVector<void *, 8> InvalidatedPassIDs;
  71   FunctionAnalysisResultListT &ResultsList = FunctionAnalysisResultLists[F];
  72   for (FunctionAnalysisResultListT::iterator I = ResultsList.begin(),
  73                                              E = ResultsList.end();
  74        I != E;)
  75     if (I->second->invalidate(F)) {
  76       InvalidatedPassIDs.push_back(I->first);
  77       I = ResultsList.erase(I);
  78     } else {
  79       ++I;
  80     }
  81   while (!InvalidatedPassIDs.empty())
  82     FunctionAnalysisResults.erase(
  83         std::make_pair(InvalidatedPassIDs.pop_back_val(), F));
  84 }
  85
  86 const detail::AnalysisResultConcept<Function> &
  87 FunctionAnalysisManager::getResultImpl(void *PassID, Function *F) {
  88   FunctionAnalysisResultMapT::iterator RI;
  89   bool Inserted;
  90   llvm::tie(RI, Inserted) = FunctionAnalysisResults.insert(std::make_pair(
  91       std::make_pair(PassID, F), FunctionAnalysisResultListT::iterator()));
  92
  93   if (Inserted) {
  94     // We don't have a cached result for this result. Look up the pass and run
  95     // it to produce a result, which we then add to the cache.
  96     FunctionAnalysisPassMapT::const_iterator PI =
  97         FunctionAnalysisPasses.find(PassID);
  98     assert(PI != FunctionAnalysisPasses.end() &&
  99            "Analysis passes must be registered prior to being queried!");
 100     FunctionAnalysisResultListT &ResultList = FunctionAnalysisResultLists[F];
 101     ResultList.push_back(std::make_pair(PassID, PI->second->run(F)));
 102     RI->second = llvm::prior(ResultList.end());
 103   }
 104
 105   return *RI->second->second;
 106 }
 107
 108 void FunctionAnalysisManager::invalidateImpl(void *PassID, Function *F) {
 109   FunctionAnalysisResultMapT::iterator RI =
 110       FunctionAnalysisResults.find(std::make_pair(PassID, F));
 111   if (RI == FunctionAnalysisResults.end())
 112     return;
 113
 114   FunctionAnalysisResultLists[F].erase(RI->second);
 115 }