LLVM 17.0.0git
LoopAnalysisManager.cpp
Go to the documentation of this file.
1//===- LoopAnalysisManager.cpp - Loop analysis management -----------------===//
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
14#include "llvm/IR/Dominators.h"
16#include <optional>
17
18using namespace llvm;
19
20namespace llvm {
21// Explicit template instantiations and specialization definitions for core
22// template typedefs.
23template class AllAnalysesOn<Loop>;
28
29bool LoopAnalysisManagerFunctionProxy::Result::invalidate(
30 Function &F, const PreservedAnalyses &PA,
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();
38
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.
48 bool invalidateMemorySSAAnalysis = false;
49 if (MSSAUsed)
50 invalidateMemorySSAAnalysis = Inv.invalidate<MemorySSAAnalysis>(F, PA);
51 if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
52 Inv.invalidate<AAManager>(F, PA) ||
55 Inv.invalidate<LoopAnalysis>(F, PA) ||
57 invalidateMemorySSAAnalysis) {
58 // Note that the LoopInfo may be stale at this point, however the loop
59 // objects themselves remain the only viable keys that could be in the
60 // analysis manager's cache. So we just walk the keys and forcibly clear
61 // those results. Note that the order doesn't matter here as this will just
62 // directly destroy the results without calling methods on them.
63 for (Loop *L : PreOrderLoops) {
64 // NB! `L` may not be in a good enough state to run Loop::getName.
65 InnerAM->clear(*L, "<possibly invalidated loop>");
66 }
67
68 // We also need to null out the inner AM so that when the object gets
69 // destroyed as invalid we don't try to clear the inner AM again. At that
70 // point we won't be able to reliably walk the loops for this function and
71 // only clear results associated with those loops the way we do here.
72 // FIXME: Making InnerAM null at this point isn't very nice. Most analyses
73 // try to remain valid during invalidation. Maybe we should add an
74 // `IsClean` flag?
75 InnerAM = nullptr;
76
77 // Now return true to indicate this *is* invalid and a fresh proxy result
78 // needs to be built. This is especially important given the null InnerAM.
79 return true;
80 }
81
82 // Directly check if the relevant set is preserved so we can short circuit
83 // invalidating loops.
84 bool AreLoopAnalysesPreserved =
86
87 // Since we have a valid LoopInfo we can actually leave the cached results in
88 // the analysis manager associated with the Loop keys, but we need to
89 // propagate any necessary invalidation logic into them. We'd like to
90 // invalidate things in roughly the same order as they were put into the
91 // cache and so we walk the preorder list in reverse to form a valid
92 // postorder.
93 for (Loop *L : reverse(PreOrderLoops)) {
94 std::optional<PreservedAnalyses> InnerPA;
95
96 // Check to see whether the preserved set needs to be adjusted based on
97 // function-level analysis invalidation triggering deferred invalidation
98 // for this loop.
99 if (auto *OuterProxy =
100 InnerAM->getCachedResult<FunctionAnalysisManagerLoopProxy>(*L))
101 for (const auto &OuterInvalidationPair :
102 OuterProxy->getOuterInvalidations()) {
103 AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first;
104 const auto &InnerAnalysisIDs = OuterInvalidationPair.second;
105 if (Inv.invalidate(OuterAnalysisID, F, PA)) {
106 if (!InnerPA)
107 InnerPA = PA;
108 for (AnalysisKey *InnerAnalysisID : InnerAnalysisIDs)
109 InnerPA->abandon(InnerAnalysisID);
110 }
111 }
112
113 // Check if we needed a custom PA set. If so we'll need to run the inner
114 // invalidation.
115 if (InnerPA) {
116 InnerAM->invalidate(*L, *InnerPA);
117 continue;
118 }
119
120 // Otherwise we only need to do invalidation if the original PA set didn't
121 // preserve all Loop analyses.
122 if (!AreLoopAnalysesPreserved)
123 InnerAM->invalidate(*L, PA);
124 }
125
126 // Return false to indicate that this result is still a valid proxy.
127 return false;
128}
129
130template <>
134 return Result(*InnerAM, AM.getResult<LoopAnalysis>(F));
135}
136}
137
144 return PA;
145}
This header provides classes for managing per-loop analyses.
#define F(x, y, z)
Definition: MD5.cpp:55
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
Provides implementations for PassManager and AnalysisManager template methods.
A manager for alias analyses.
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
Definition: PassManager.h:90
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:661
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Trigger the invalidation of some other analysis pass if not already handled and return whether it was...
Definition: PassManager.h:679
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:774
A function analysis which provides an AssumptionCache.
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:279
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:933
Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
Definition: PassManager.h:994
Analysis pass that exposes the LoopInfo for a function.
Definition: LoopInfo.h:1268
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:547
An analysis that produces MemorySSA for a function.
Definition: MemorySSA.h:936
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Definition: PassManager.h:1058
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
bool allAnalysesInSetPreserved() const
Directly test whether a set of analyses is preserved.
Definition: PassManager.h:335
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
Definition: PassManager.h:310
void abandon()
Mark an analysis as abandoned.
Definition: PassManager.h:206
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:173
Analysis pass that exposes the ScalarEvolution for a function.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition: PassManager.h:912
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:484
PreservedAnalyses getLoopPassPreservedAnalyses()
Returns the minimum set of Analyses that all loop passes must preserve.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...