1 //===- PassManager.cpp - Infrastructure for managing & running IR passes --===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/IR/PassManager.h" 10 #include "llvm/ADT/STLExtras.h" 11 #include "llvm/IR/LLVMContext.h" 12 #include "llvm/IR/PassManagerImpl.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 } // namespace llvm 93 94 AnalysisSetKey CFGAnalyses::SetKey; 95 96 AnalysisSetKey PreservedAnalyses::AllAnalysesKey; 97