LLVM 17.0.0git
LoopAnalysisManager.h
Go to the documentation of this file.
1//===- LoopAnalysisManager.h - Loop analysis management ---------*- C++ -*-===//
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/// \file
9///
10/// This header provides classes for managing per-loop analyses. These are
11/// typically used as part of a loop pass pipeline over the loop nests of
12/// a function.
13///
14/// Loop analyses are allowed to make some simplifying assumptions:
15/// 1) Loops are, where possible, in simplified form.
16/// 2) Loops are *always* in LCSSA form.
17/// 3) A collection of analysis results are available:
18/// - LoopInfo
19/// - DominatorTree
20/// - ScalarEvolution
21/// - AAManager
22///
23/// The primary mechanism to provide these invariants is the loop pass manager,
24/// but they can also be manually provided in order to reason about a loop from
25/// outside of a dedicated pass manager.
26///
27//===----------------------------------------------------------------------===//
28
29#ifndef LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
30#define LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
31
32#include "llvm/IR/PassManager.h"
33
34namespace llvm {
35
36class AAResults;
37class AssumptionCache;
38class DominatorTree;
39class Function;
40class Loop;
41class LoopInfo;
42class MemorySSA;
43class ScalarEvolution;
44class TargetLibraryInfo;
45class TargetTransformInfo;
46
47/// The adaptor from a function pass to a loop pass computes these analyses and
48/// makes them available to the loop passes "for free". Each loop pass is
49/// expected to update these analyses if necessary to ensure they're
50/// valid after it runs.
62};
63
64/// Extern template declaration for the analysis set for this IR unit.
65extern template class AllAnalysesOn<Loop>;
66
68/// The loop analysis manager.
69///
70/// See the documentation for the AnalysisManager template for detail
71/// documentation. This typedef serves as a convenient way to refer to this
72/// construct in the adaptors and proxies used to integrate this into the larger
73/// pass manager infrastructure.
76
77/// A proxy from a \c LoopAnalysisManager to a \c Function.
80
81/// A specialized result for the \c LoopAnalysisManagerFunctionProxy which
82/// retains a \c LoopInfo reference.
83///
84/// This allows it to collect loop objects for which analysis results may be
85/// cached in the \c LoopAnalysisManager.
87public:
88 explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
89 : InnerAM(&InnerAM), LI(&LI) {}
91 : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI), MSSAUsed(Arg.MSSAUsed) {
92 // We have to null out the analysis manager in the moved-from state
93 // because we are taking ownership of the responsibilty to clear the
94 // analysis state.
95 Arg.InnerAM = nullptr;
96 }
98 InnerAM = RHS.InnerAM;
99 LI = RHS.LI;
100 MSSAUsed = RHS.MSSAUsed;
101 // We have to null out the analysis manager in the moved-from state
102 // because we are taking ownership of the responsibilty to clear the
103 // analysis state.
104 RHS.InnerAM = nullptr;
105 return *this;
106 }
108 // InnerAM is cleared in a moved from state where there is nothing to do.
109 if (!InnerAM)
110 return;
111
112 // Clear out the analysis manager if we're being destroyed -- it means we
113 // didn't even see an invalidate call when we got invalidated.
114 InnerAM->clear();
115 }
116
117 /// Mark MemorySSA as used so we can invalidate self if MSSA is invalidated.
118 void markMSSAUsed() { MSSAUsed = true; }
119
120 /// Accessor for the analysis manager.
121 LoopAnalysisManager &getManager() { return *InnerAM; }
122
123 /// Handler for invalidation of the proxy for a particular function.
124 ///
125 /// If the proxy, \c LoopInfo, and associated analyses are preserved, this
126 /// will merely forward the invalidation event to any cached loop analysis
127 /// results for loops within this function.
128 ///
129 /// If the necessary loop infrastructure is not preserved, this will forcibly
130 /// clear all of the cached analysis results that are keyed on the \c
131 /// LoopInfo for this function.
134
135private:
136 LoopAnalysisManager *InnerAM;
137 LoopInfo *LI;
138 bool MSSAUsed = false;
139};
140
141/// Provide a specialized run method for the \c LoopAnalysisManagerFunctionProxy
142/// so it can pass the \c LoopInfo to the result.
143template <>
146
147// Ensure the \c LoopAnalysisManagerFunctionProxy is provided as an extern
148// template.
150
153/// A proxy from a \c FunctionAnalysisManager to a \c Loop.
157
158/// Returns the minimum set of Analyses that all loop passes must preserve.
160}
161
162#endif // LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
early cse Early CSE w MemorySSA
Definition: EarlyCSE.cpp:1809
#define F(x, y, z)
Definition: MD5.cpp:55
This header defines various interfaces for pass management in LLVM.
Value * RHS
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
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
A cache of @llvm.assume calls within a function.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Analysis providing branch probability information.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
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
A specialized result for the LoopAnalysisManagerFunctionProxy which retains a LoopInfo reference.
LoopAnalysisManager & getManager()
Accessor for the analysis manager.
bool invalidate(Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &Inv)
Handler for invalidation of the proxy for a particular function.
void markMSSAUsed()
Mark MemorySSA as used so we can invalidate self if MSSA is invalidated.
Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:547
Encapsulates MemorySSA, including all data associated with memory accesses.
Definition: MemorySSA.h:700
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
The main scalar evolution driver.
Provides information about what library functions are available for the current target.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
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
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1862
PreservedAnalyses getLoopPassPreservedAnalyses()
Returns the minimum set of Analyses that all loop passes must preserve.
Definition: BitVector.h:851
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...