1 //===- LoopAnalysisManager.cpp - Loop analysis management -----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/Analysis/LoopAnalysisManager.h"
11 #include "llvm/Analysis/BasicAliasAnalysis.h"
12 #include "llvm/Analysis/GlobalsModRef.h"
13 #include "llvm/Analysis/LoopInfo.h"
14 #include "llvm/Analysis/ScalarEvolution.h"
15 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
16 #include "llvm/IR/Dominators.h"
20 // Explicit template instantiations and specialization defininitions for core
23 template class AllAnalysesOn<Loop>;
24 template class AnalysisManager<Loop, LoopStandardAnalysisResults &>;
25 template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
26 template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
27 LoopStandardAnalysisResults &>;
29 bool LoopAnalysisManagerFunctionProxy::Result::invalidate(
30 Function &F, const PreservedAnalyses &PA,
31 FunctionAnalysisManager::Invalidator &Inv) {
32 // First compute the sequence of IR units covered by this proxy. We will want
33 // to visit this in postorder, but because this is a tree structure we can do
34 // this by building a preorder sequence and walking it backwards. We also
35 // want siblings in forward program order to match the LoopPassManager so we
36 // get the preorder with siblings reversed.
37 SmallVector<Loop *, 4> PreOrderLoops = LI->getLoopsInReverseSiblingPreorder();
39 // If this proxy or the loop info is going to be invalidated, we also need
40 // to clear all the keys coming from that analysis. We also completely blow
41 // away the loop analyses if any of the standard analyses provided by the
42 // loop pass manager go away so that loop analyses can freely use these
43 // without worrying about declaring dependencies on them etc.
44 // FIXME: It isn't clear if this is the right tradeoff. We could instead make
45 // loop analyses declare any dependencies on these and use the more general
46 // invalidation logic below to act on that.
47 auto PAC = PA.getChecker<LoopAnalysisManagerFunctionProxy>();
48 if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
49 Inv.invalidate<AAManager>(F, PA) ||
50 Inv.invalidate<AssumptionAnalysis>(F, PA) ||
51 Inv.invalidate<DominatorTreeAnalysis>(F, PA) ||
52 Inv.invalidate<LoopAnalysis>(F, PA) ||
53 Inv.invalidate<ScalarEvolutionAnalysis>(F, PA)) {
54 // Note that the LoopInfo may be stale at this point, however the loop
55 // objects themselves remain the only viable keys that could be in the
56 // analysis manager's cache. So we just walk the keys and forcibly clear
57 // those results. Note that the order doesn't matter here as this will just
58 // directly destroy the results without calling methods on them.
59 for (Loop *L : PreOrderLoops)
62 // We also need to null out the inner AM so that when the object gets
63 // destroyed as invalid we don't try to clear the inner AM again. At that
64 // point we won't be able to reliably walk the loops for this function and
65 // only clear results associated with those loops the way we do here.
66 // FIXME: Making InnerAM null at this point isn't very nice. Most analyses
67 // try to remain valid during invalidation. Maybe we should add an
71 // Now return true to indicate this *is* invalid and a fresh proxy result
72 // needs to be built. This is especially important given the null InnerAM.
76 // Directly check if the relevant set is preserved so we can short circuit
77 // invalidating loops.
78 bool AreLoopAnalysesPreserved =
79 PA.allAnalysesInSetPreserved<AllAnalysesOn<Loop>>();
81 // Since we have a valid LoopInfo we can actually leave the cached results in
82 // the analysis manager associated with the Loop keys, but we need to
83 // propagate any necessary invalidation logic into them. We'd like to
84 // invalidate things in roughly the same order as they were put into the
85 // cache and so we walk the preorder list in reverse to form a valid
87 for (Loop *L : reverse(PreOrderLoops)) {
88 Optional<PreservedAnalyses> InnerPA;
90 // Check to see whether the preserved set needs to be adjusted based on
91 // function-level analysis invalidation triggering deferred invalidation
93 if (auto *OuterProxy =
94 InnerAM->getCachedResult<FunctionAnalysisManagerLoopProxy>(*L))
95 for (const auto &OuterInvalidationPair :
96 OuterProxy->getOuterInvalidations()) {
97 AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first;
98 const auto &InnerAnalysisIDs = OuterInvalidationPair.second;
99 if (Inv.invalidate(OuterAnalysisID, F, PA)) {
102 for (AnalysisKey *InnerAnalysisID : InnerAnalysisIDs)
103 InnerPA->abandon(InnerAnalysisID);
107 // Check if we needed a custom PA set. If so we'll need to run the inner
110 InnerAM->invalidate(*L, *InnerPA);
114 // Otherwise we only need to do invalidation if the original PA set didn't
115 // preserve all Loop analyses.
116 if (!AreLoopAnalysesPreserved)
117 InnerAM->invalidate(*L, PA);
120 // Return false to indicate that this result is still a valid proxy.
125 LoopAnalysisManagerFunctionProxy::Result
126 LoopAnalysisManagerFunctionProxy::run(Function &F,
127 FunctionAnalysisManager &AM) {
128 return Result(*InnerAM, AM.getResult<LoopAnalysis>(F));
132 PreservedAnalyses llvm::getLoopPassPreservedAnalyses() {
133 PreservedAnalyses PA;
134 PA.preserve<DominatorTreeAnalysis>();
135 PA.preserve<LoopAnalysis>();
136 PA.preserve<LoopAnalysisManagerFunctionProxy>();
137 PA.preserve<ScalarEvolutionAnalysis>();
138 // TODO: What we really want to do here is preserve an AA category, but that
139 // concept doesn't exist yet.
140 PA.preserve<AAManager>();
141 PA.preserve<BasicAA>();
142 PA.preserve<GlobalsAA>();
143 PA.preserve<SCEVAA>();