Line data    Source code

       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         798 : 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         798 :   if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Module>>()) {
      46         262 :     InnerAM->clear();
      47         262 :     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        4161 :   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        3625 :             InnerAM->getCachedResult<ModuleAnalysisManagerFunctionProxy>(F))
      64             :       for (const auto &OuterInvalidationPair :
      65         588 :            OuterProxy->getOuterInvalidations()) {
      66          94 :         AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first;
      67             :         const auto &InnerAnalysisIDs = OuterInvalidationPair.second;
      68          94 :         if (Inv.invalidate(OuterAnalysisID, M, PA)) {
      69          82 :           if (!FunctionPA)
      70             :             FunctionPA = PA;
      71         164 :           for (AnalysisKey *InnerAnalysisID : InnerAnalysisIDs)
      72          82 :             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        3625 :     if (FunctionPA) {
      79          82 :       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        3543 :     if (!AreFunctionAnalysesPreserved)
      86        1131 :       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;