lib/IR/PassManager.cpp

   1 //===- PassManager.cpp - 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 #include "llvm/IR/LLVMContext.h"
  13
  14 using namespace llvm;
  15
  16 // Explicit template instantiations and specialization defininitions for core
  17 // template typedefs.
  18 namespace llvm {
  19 template class AllAnalysesOn<Module>;
  20 template class AllAnalysesOn<Function>;
  21 template class PassManager<Module>;
  22 template class PassManager<Function>;
  23 template class AnalysisManager<Module>;
  24 template class AnalysisManager<Function>;
  25 template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>;
  26 template class OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>;
  27
  28 template <>
  29 bool FunctionAnalysisManagerModuleProxy::Result::invalidate(
  30     Module &M, const PreservedAnalyses &PA,
  31     ModuleAnalysisManager::Invalidator &Inv) {
  32   // If literally everything is preserved, we're done.
  33   if (PA.areAllPreserved())
  34     return false; // This is still a valid proxy.
  35
  36   // If this proxy isn't marked as preserved, then even if the result remains
  37   // valid, the key itself may no longer be valid, so we clear everything.
  38   //
  39   // Note that in order to preserve this proxy, a module pass must ensure that
  40   // the FAM has been completely updated to handle the deletion of functions.
  41   // Specifically, any FAM-cached results for those functions need to have been
  42   // forcibly cleared. When preserved, this proxy will only invalidate results
  43   // cached on functions *still in the module* at the end of the module pass.
  44   auto PAC = PA.getChecker<FunctionAnalysisManagerModuleProxy>();
  45   if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Module>>()) {
  46     InnerAM->clear();
  47     return true;
  48   }
  49
  50   // Directly check if the relevant set is preserved.
  51   bool AreFunctionAnalysesPreserved =
  52       PA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>();
  53
  54   // Now walk all the functions to see if any inner analysis invalidation is
  55   // necessary.
  56   for (Function &F : M) {
  57     Optional<PreservedAnalyses> FunctionPA;
  58
  59     // Check to see whether the preserved set needs to be pruned based on
  60     // module-level analysis invalidation that triggers deferred invalidation
  61     // registered with the outer analysis manager proxy for this function.
  62     if (auto *OuterProxy =
  63             InnerAM->getCachedResult<ModuleAnalysisManagerFunctionProxy>(F))
  64       for (const auto &OuterInvalidationPair :
  65            OuterProxy->getOuterInvalidations()) {
  66         AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first;
  67         const auto &InnerAnalysisIDs = OuterInvalidationPair.second;
  68         if (Inv.invalidate(OuterAnalysisID, M, PA)) {
  69           if (!FunctionPA)
  70             FunctionPA = PA;
  71           for (AnalysisKey *InnerAnalysisID : InnerAnalysisIDs)
  72             FunctionPA->abandon(InnerAnalysisID);
  73         }
  74       }
  75
  76     // Check if we needed a custom PA set, and if so we'll need to run the
  77     // inner invalidation.
  78     if (FunctionPA) {
  79       InnerAM->invalidate(F, *FunctionPA);
  80       continue;
  81     }
  82
  83     // Otherwise we only need to do invalidation if the original PA set didn't
  84     // preserve all function analyses.
  85     if (!AreFunctionAnalysesPreserved)
  86       InnerAM->invalidate(F, PA);
  87   }
  88
  89   // Return false to indicate that this result is still a valid proxy.
  90   return false;
  91 }
  92 }
  93
  94 AnalysisSetKey CFGAnalyses::SetKey;
  95
  96 AnalysisSetKey PreservedAnalyses::AllAnalysesKey;