Home | History | Annotate | Download | only in Analysis 
      1 //===- CGSCCPassManager.cpp - Managing & running CGSCC 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/Analysis/CGSCCPassManager.h"
     11 #include "llvm/Support/CommandLine.h"
     12 #include "llvm/Support/Debug.h"
     13 
     14 using namespace llvm;
     15 
     16 static cl::opt<bool>
     17 DebugPM("debug-cgscc-pass-manager", cl::Hidden,
     18         cl::desc("Print CGSCC pass management debugging information"));
     19 
     20 PreservedAnalyses CGSCCPassManager::run(LazyCallGraph::SCC *C,
     21                                         CGSCCAnalysisManager *AM) {
     22   PreservedAnalyses PA = PreservedAnalyses::all();
     23 
     24   if (DebugPM)
     25     dbgs() << "Starting CGSCC pass manager run.\n";
     26 
     27   for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
     28     if (DebugPM)
     29       dbgs() << "Running CGSCC pass: " << Passes[Idx]->name() << "\n";
     30 
     31     PreservedAnalyses PassPA = Passes[Idx]->run(C, AM);
     32     if (AM)
     33       AM->invalidate(C, PassPA);
     34     PA.intersect(std::move(PassPA));
     35   }
     36 
     37   if (DebugPM)
     38     dbgs() << "Finished CGSCC pass manager run.\n";
     39 
     40   return PA;
     41 }
     42 
     43 bool CGSCCAnalysisManager::empty() const {
     44   assert(CGSCCAnalysisResults.empty() == CGSCCAnalysisResultLists.empty() &&
     45          "The storage and index of analysis results disagree on how many there "
     46          "are!");
     47   return CGSCCAnalysisResults.empty();
     48 }
     49 
     50 void CGSCCAnalysisManager::clear() {
     51   CGSCCAnalysisResults.clear();
     52   CGSCCAnalysisResultLists.clear();
     53 }
     54 
     55 CGSCCAnalysisManager::ResultConceptT &
     56 CGSCCAnalysisManager::getResultImpl(void *PassID, LazyCallGraph::SCC *C) {
     57   CGSCCAnalysisResultMapT::iterator RI;
     58   bool Inserted;
     59   std::tie(RI, Inserted) = CGSCCAnalysisResults.insert(std::make_pair(
     60       std::make_pair(PassID, C), CGSCCAnalysisResultListT::iterator()));
     61 
     62   // If we don't have a cached result for this function, look up the pass and
     63   // run it to produce a result, which we then add to the cache.
     64   if (Inserted) {
     65     CGSCCAnalysisResultListT &ResultList = CGSCCAnalysisResultLists[C];
     66     ResultList.emplace_back(PassID, lookupPass(PassID).run(C, this));
     67     RI->second = std::prev(ResultList.end());
     68   }
     69 
     70   return *RI->second->second;
     71 }
     72 
     73 CGSCCAnalysisManager::ResultConceptT *
     74 CGSCCAnalysisManager::getCachedResultImpl(void *PassID,
     75                                           LazyCallGraph::SCC *C) const {
     76   CGSCCAnalysisResultMapT::const_iterator RI =
     77       CGSCCAnalysisResults.find(std::make_pair(PassID, C));
     78   return RI == CGSCCAnalysisResults.end() ? nullptr : &*RI->second->second;
     79 }
     80 
     81 void CGSCCAnalysisManager::invalidateImpl(void *PassID, LazyCallGraph::SCC *C) {
     82   CGSCCAnalysisResultMapT::iterator RI =
     83       CGSCCAnalysisResults.find(std::make_pair(PassID, C));
     84   if (RI == CGSCCAnalysisResults.end())
     85     return;
     86 
     87   CGSCCAnalysisResultLists[C].erase(RI->second);
     88 }
     89 
     90 void CGSCCAnalysisManager::invalidateImpl(LazyCallGraph::SCC *C,
     91                                           const PreservedAnalyses &PA) {
     92   // Clear all the invalidated results associated specifically with this
     93   // function.
     94   SmallVector<void *, 8> InvalidatedPassIDs;
     95   CGSCCAnalysisResultListT &ResultsList = CGSCCAnalysisResultLists[C];
     96   for (CGSCCAnalysisResultListT::iterator I = ResultsList.begin(),
     97                                           E = ResultsList.end();
     98        I != E;)
     99     if (I->second->invalidate(C, PA)) {
    100       InvalidatedPassIDs.push_back(I->first);
    101       I = ResultsList.erase(I);
    102     } else {
    103       ++I;
    104     }
    105   while (!InvalidatedPassIDs.empty())
    106     CGSCCAnalysisResults.erase(
    107         std::make_pair(InvalidatedPassIDs.pop_back_val(), C));
    108   CGSCCAnalysisResultLists.erase(C);
    109 }
    110 
    111 char CGSCCAnalysisManagerModuleProxy::PassID;
    112 
    113 CGSCCAnalysisManagerModuleProxy::Result
    114 CGSCCAnalysisManagerModuleProxy::run(Module *M) {
    115   assert(CGAM->empty() && "CGSCC analyses ran prior to the module proxy!");
    116   return Result(*CGAM);
    117 }
    118 
    119 CGSCCAnalysisManagerModuleProxy::Result::~Result() {
    120   // Clear out the analysis manager if we're being destroyed -- it means we
    121   // didn't even see an invalidate call when we got invalidated.
    122   CGAM->clear();
    123 }
    124 
    125 bool CGSCCAnalysisManagerModuleProxy::Result::invalidate(
    126     Module *M, const PreservedAnalyses &PA) {
    127   // If this proxy isn't marked as preserved, then we can't even invalidate
    128   // individual CGSCC analyses, there may be an invalid set of SCC objects in
    129   // the cache making it impossible to incrementally preserve them.
    130   // Just clear the entire manager.
    131   if (!PA.preserved(ID()))
    132     CGAM->clear();
    133 
    134   // Return false to indicate that this result is still a valid proxy.
    135   return false;
    136 }
    137 
    138 char ModuleAnalysisManagerCGSCCProxy::PassID;
    139 
    140 char FunctionAnalysisManagerCGSCCProxy::PassID;
    141 
    142 FunctionAnalysisManagerCGSCCProxy::Result
    143 FunctionAnalysisManagerCGSCCProxy::run(LazyCallGraph::SCC *C) {
    144   assert(FAM->empty() && "Function analyses ran prior to the CGSCC proxy!");
    145   return Result(*FAM);
    146 }
    147 
    148 FunctionAnalysisManagerCGSCCProxy::Result::~Result() {
    149   // Clear out the analysis manager if we're being destroyed -- it means we
    150   // didn't even see an invalidate call when we got invalidated.
    151   FAM->clear();
    152 }
    153 
    154 bool FunctionAnalysisManagerCGSCCProxy::Result::invalidate(
    155     LazyCallGraph::SCC *C, const PreservedAnalyses &PA) {
    156   // If this proxy isn't marked as preserved, then we can't even invalidate
    157   // individual function analyses, there may be an invalid set of Function
    158   // objects in the cache making it impossible to incrementally preserve them.
    159   // Just clear the entire manager.
    160   if (!PA.preserved(ID()))
    161     FAM->clear();
    162 
    163   // Return false to indicate that this result is still a valid proxy.
    164   return false;
    165 }
    166 
    167 char CGSCCAnalysisManagerFunctionProxy::PassID;
    168