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) {
  16   PreservedAnalyses PA = PreservedAnalyses::all();
  17   for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
  18     PreservedAnalyses PassPA = Passes[Idx]->run(M);
  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 (!PA.preserved(I->first) && I->second->invalidate(M))
  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);
  51   }
  52
  53   return *RI->second;
  54 }
  55
  56 void ModuleAnalysisManager::invalidateImpl(void *PassID, Module *M) {
  57   ModuleAnalysisResults.erase(PassID);
  58 }
  59
  60 PreservedAnalyses FunctionPassManager::run(Function *F) {
  61   PreservedAnalyses PA = PreservedAnalyses::all();
  62   for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
  63     PreservedAnalyses PassPA = Passes[Idx]->run(F);
  64     if (AM)
  65       AM->invalidate(F, PassPA);
  66     PA.intersect(llvm_move(PassPA));
  67   }
  68   return PA;
  69 }
  70
  71 void FunctionAnalysisManager::invalidate(Function *F, const PreservedAnalyses &PA) {
  72   // Clear all the invalidated results associated specifically with this
  73   // function.
  74   SmallVector<void *, 8> InvalidatedPassIDs;
  75   FunctionAnalysisResultListT &ResultsList = FunctionAnalysisResultLists[F];
  76   for (FunctionAnalysisResultListT::iterator I = ResultsList.begin(),
  77                                              E = ResultsList.end();
  78        I != E;)
  79     if (!PA.preserved(I->first) && I->second->invalidate(F)) {
  80       InvalidatedPassIDs.push_back(I->first);
  81       I = ResultsList.erase(I);
  82     } else {
  83       ++I;
  84     }
  85   while (!InvalidatedPassIDs.empty())
  86     FunctionAnalysisResults.erase(
  87         std::make_pair(InvalidatedPassIDs.pop_back_val(), F));
  88 }
  89
  90 bool FunctionAnalysisManager::empty() const {
  91   assert(FunctionAnalysisResults.empty() ==
  92              FunctionAnalysisResultLists.empty() &&
  93          "The storage and index of analysis results disagree on how many there "
  94          "are!");
  95   return FunctionAnalysisResults.empty();
  96 }
  97
  98 void FunctionAnalysisManager::clear() {
  99   FunctionAnalysisResults.clear();
 100   FunctionAnalysisResultLists.clear();
 101 }
 102
 103 const detail::AnalysisResultConcept<Function> &
 104 FunctionAnalysisManager::getResultImpl(void *PassID, Function *F) {
 105   FunctionAnalysisResultMapT::iterator RI;
 106   bool Inserted;
 107   llvm::tie(RI, Inserted) = FunctionAnalysisResults.insert(std::make_pair(
 108       std::make_pair(PassID, F), FunctionAnalysisResultListT::iterator()));
 109
 110   if (Inserted) {
 111     // We don't have a cached result for this result. Look up the pass and run
 112     // it to produce a result, which we then add to the cache.
 113     FunctionAnalysisPassMapT::const_iterator PI =
 114         FunctionAnalysisPasses.find(PassID);
 115     assert(PI != FunctionAnalysisPasses.end() &&
 116            "Analysis passes must be registered prior to being queried!");
 117     FunctionAnalysisResultListT &ResultList = FunctionAnalysisResultLists[F];
 118     ResultList.push_back(std::make_pair(PassID, PI->second->run(F)));
 119     RI->second = llvm::prior(ResultList.end());
 120   }
 121
 122   return *RI->second->second;
 123 }
 124
 125 void FunctionAnalysisManager::invalidateImpl(void *PassID, Function *F) {
 126   FunctionAnalysisResultMapT::iterator RI =
 127       FunctionAnalysisResults.find(std::make_pair(PassID, F));
 128   if (RI == FunctionAnalysisResults.end())
 129     return;
 130
 131   FunctionAnalysisResultLists[F].erase(RI->second);
 132 }
 133
 134 char FunctionAnalysisModuleProxy::PassID;
 135
 136 FunctionAnalysisModuleProxy::Result
 137 FunctionAnalysisModuleProxy::run(Module *M) {
 138   assert(FAM.empty() && "Function analyses ran prior to the module proxy!");
 139   return Result(FAM);
 140 }
 141
 142 FunctionAnalysisModuleProxy::Result::~Result() {
 143   // Clear out the analysis manager if we're being destroyed -- it means we
 144   // didn't even see an invalidate call when we got invalidated.
 145   FAM.clear();
 146 }
 147
 148 bool FunctionAnalysisModuleProxy::Result::invalidate(Module *M) {
 149   // FIXME: We should pull the preserved analysis set into the invalidation
 150   // handler so that we can detect when there is no need to clear the entire
 151   // function analysis manager.
 152   FAM.clear();
 153
 154   // Return false to indicate that this result is still a valid proxy.
 155   return false;
 156 }