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 PreservedAnalyses ModulePassManager::run(Module *M, ModuleAnalysisManager *AM) {
  16   PreservedAnalyses PA = PreservedAnalyses::all();
  17   for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
  18     PreservedAnalyses PassPA = Passes[Idx]->run(M, AM);
  19     if (AM)
  20       AM->invalidate(M, PassPA);
  21     PA.intersect(llvm_move(PassPA));
  22   }
  23   return PA;
  24 }
  25
  26 void ModuleAnalysisManager::invalidate(Module *M, const PreservedAnalyses &PA) {
  27   // FIXME: This is a total hack based on the fact that erasure doesn't
  28   // invalidate iteration for DenseMap.
  29   for (ModuleAnalysisResultMapT::iterator I = ModuleAnalysisResults.begin(),
  30                                           E = ModuleAnalysisResults.end();
  31        I != E; ++I)
  32     if (I->second->invalidate(M, PA))
  33       ModuleAnalysisResults.erase(I);
  34 }
  35
  36 const detail::AnalysisResultConcept<Module *> &
  37 ModuleAnalysisManager::getResultImpl(void *PassID, Module *M) {
  38   ModuleAnalysisResultMapT::iterator RI;
  39   bool Inserted;
  40   llvm::tie(RI, Inserted) = ModuleAnalysisResults.insert(std::make_pair(
  41       PassID, polymorphic_ptr<detail::AnalysisResultConcept<Module *> >()));
  42
  43   if (Inserted) {
  44     // We don't have a cached result for this result. Look up the pass and run
  45     // it to produce a result, which we then add to the cache.
  46     ModuleAnalysisPassMapT::const_iterator PI =
  47         ModuleAnalysisPasses.find(PassID);
  48     assert(PI != ModuleAnalysisPasses.end() &&
  49            "Analysis passes must be registered prior to being queried!");
  50     RI->second = PI->second->run(M, this);
  51   }
  52
  53   return *RI->second;
  54 }
  55
  56 const detail::AnalysisResultConcept<Module *> *
  57 ModuleAnalysisManager::getCachedResultImpl(void *PassID, Module *M) const {
  58   ModuleAnalysisResultMapT::const_iterator RI = ModuleAnalysisResults.find(PassID);
  59   return RI == ModuleAnalysisResults.end() ? 0 : &*RI->second;
  60 }
  61
  62 void ModuleAnalysisManager::invalidateImpl(void *PassID, Module *M) {
  63   ModuleAnalysisResults.erase(PassID);
  64 }
  65
  66 PreservedAnalyses FunctionPassManager::run(Function *F, FunctionAnalysisManager *AM) {
  67   PreservedAnalyses PA = PreservedAnalyses::all();
  68   for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
  69     PreservedAnalyses PassPA = Passes[Idx]->run(F, AM);
  70     if (AM)
  71       AM->invalidate(F, PassPA);
  72     PA.intersect(llvm_move(PassPA));
  73   }
  74   return PA;
  75 }
  76
  77 void FunctionAnalysisManager::invalidate(Function *F, const PreservedAnalyses &PA) {
  78   // Clear all the invalidated results associated specifically with this
  79   // function.
  80   SmallVector<void *, 8> InvalidatedPassIDs;
  81   FunctionAnalysisResultListT &ResultsList = FunctionAnalysisResultLists[F];
  82   for (FunctionAnalysisResultListT::iterator I = ResultsList.begin(),
  83                                              E = ResultsList.end();
  84        I != E;)
  85     if (I->second->invalidate(F, PA)) {
  86       InvalidatedPassIDs.push_back(I->first);
  87       I = ResultsList.erase(I);
  88     } else {
  89       ++I;
  90     }
  91   while (!InvalidatedPassIDs.empty())
  92     FunctionAnalysisResults.erase(
  93         std::make_pair(InvalidatedPassIDs.pop_back_val(), F));
  94 }
  95
  96 bool FunctionAnalysisManager::empty() const {
  97   assert(FunctionAnalysisResults.empty() ==
  98              FunctionAnalysisResultLists.empty() &&
  99          "The storage and index of analysis results disagree on how many there "
 100          "are!");
 101   return FunctionAnalysisResults.empty();
 102 }
 103
 104 void FunctionAnalysisManager::clear() {
 105   FunctionAnalysisResults.clear();
 106   FunctionAnalysisResultLists.clear();
 107 }
 108
 109 const detail::AnalysisResultConcept<Function *> &
 110 FunctionAnalysisManager::getResultImpl(void *PassID, Function *F) {
 111   FunctionAnalysisResultMapT::iterator RI;
 112   bool Inserted;
 113   llvm::tie(RI, Inserted) = FunctionAnalysisResults.insert(std::make_pair(
 114       std::make_pair(PassID, F), FunctionAnalysisResultListT::iterator()));
 115
 116   if (Inserted) {
 117     // We don't have a cached result for this result. Look up the pass and run
 118     // it to produce a result, which we then add to the cache.
 119     FunctionAnalysisPassMapT::const_iterator PI =
 120         FunctionAnalysisPasses.find(PassID);
 121     assert(PI != FunctionAnalysisPasses.end() &&
 122            "Analysis passes must be registered prior to being queried!");
 123     FunctionAnalysisResultListT &ResultList = FunctionAnalysisResultLists[F];
 124     ResultList.push_back(std::make_pair(PassID, PI->second->run(F, this)));
 125     RI->second = llvm::prior(ResultList.end());
 126   }
 127
 128   return *RI->second->second;
 129 }
 130
 131 const detail::AnalysisResultConcept<Function *> *
 132 FunctionAnalysisManager::getCachedResultImpl(void *PassID, Function *F) const {
 133   FunctionAnalysisResultMapT::const_iterator RI =
 134       FunctionAnalysisResults.find(std::make_pair(PassID, F));
 135   return RI == FunctionAnalysisResults.end() ? 0 : &*RI->second->second;
 136 }
 137
 138 void FunctionAnalysisManager::invalidateImpl(void *PassID, Function *F) {
 139   FunctionAnalysisResultMapT::iterator RI =
 140       FunctionAnalysisResults.find(std::make_pair(PassID, F));
 141   if (RI == FunctionAnalysisResults.end())
 142     return;
 143
 144   FunctionAnalysisResultLists[F].erase(RI->second);
 145 }
 146
 147 char FunctionAnalysisManagerModuleProxy::PassID;
 148
 149 FunctionAnalysisManagerModuleProxy::Result
 150 FunctionAnalysisManagerModuleProxy::run(Module *M) {
 151   assert(FAM.empty() && "Function analyses ran prior to the module proxy!");
 152   return Result(FAM);
 153 }
 154
 155 FunctionAnalysisManagerModuleProxy::Result::~Result() {
 156   // Clear out the analysis manager if we're being destroyed -- it means we
 157   // didn't even see an invalidate call when we got invalidated.
 158   FAM.clear();
 159 }
 160
 161 bool FunctionAnalysisManagerModuleProxy::Result::invalidate(
 162     Module *M, const PreservedAnalyses &PA) {
 163   // If this proxy isn't marked as preserved, then we can't even invalidate
 164   // individual function analyses, there may be an invalid set of Function
 165   // objects in the cache making it impossible to incrementally preserve them.
 166   // Just clear the entire manager.
 167   if (!PA.preserved(ID()))
 168     FAM.clear();
 169
 170   // Return false to indicate that this result is still a valid proxy.
 171   return false;
 172 }
 173
 174 char ModuleAnalysisManagerFunctionProxy::PassID;