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 <>
invalidate(Module & M,const PreservedAnalyses & PA,ModuleAnalysisManager::Invalidator & Inv)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;
97