LLVM 20.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 BlockFrequencyInfo;
39class BranchProbabilityInfo;
40class DominatorTree;
41class Function;
42class Loop;
43class LoopInfo;
44class MemorySSA;
45class ScalarEvolution;
46class TargetLibraryInfo;
47class TargetTransformInfo;
48
49/// The adaptor from a function pass to a loop pass computes these analyses and
50/// makes them available to the loop passes "for free". Each loop pass is
51/// expected to update these analyses if necessary to ensure they're
52/// valid after it runs.
64};
65
66/// Extern template declaration for the analysis set for this IR unit.
67extern template class AllAnalysesOn<Loop>;
68
70/// The loop analysis manager.
71///
72/// See the documentation for the AnalysisManager template for detail
73/// documentation. This typedef serves as a convenient way to refer to this
74/// construct in the adaptors and proxies used to integrate this into the larger
75/// pass manager infrastructure.
78
79/// A proxy from a \c LoopAnalysisManager to a \c Function.
82
83/// A specialized result for the \c LoopAnalysisManagerFunctionProxy which
84/// retains a \c LoopInfo reference.
85///
86/// This allows it to collect loop objects for which analysis results may be
87/// cached in the \c LoopAnalysisManager.
89public:
90 explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
91 : InnerAM(&InnerAM), LI(&LI) {}
93 : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI), MSSAUsed(Arg.MSSAUsed) {
94 // We have to null out the analysis manager in the moved-from state
95 // because we are taking ownership of the responsibilty to clear the
96 // analysis state.
97 Arg.InnerAM = nullptr;
98 }
100 InnerAM = RHS.InnerAM;
101 LI = RHS.LI;
102 MSSAUsed = RHS.MSSAUsed;
103 // We have to null out the analysis manager in the moved-from state
104 // because we are taking ownership of the responsibilty to clear the
105 // analysis state.
106 RHS.InnerAM = nullptr;
107 return *this;
108 }
110 // InnerAM is cleared in a moved from state where there is nothing to do.
111 if (!InnerAM)
112 return;
113
114 // Clear out the analysis manager if we're being destroyed -- it means we
115 // didn't even see an invalidate call when we got invalidated.
116 InnerAM->clear();
117 }
118
119 /// Mark MemorySSA as used so we can invalidate self if MSSA is invalidated.
120 void markMSSAUsed() { MSSAUsed = true; }
121
122 /// Accessor for the analysis manager.
123 LoopAnalysisManager &getManager() { return *InnerAM; }
124
125 /// Handler for invalidation of the proxy for a particular function.
126 ///
127 /// If the proxy, \c LoopInfo, and associated analyses are preserved, this
128 /// will merely forward the invalidation event to any cached loop analysis
129 /// results for loops within this function.
130 ///
131 /// If the necessary loop infrastructure is not preserved, this will forcibly
132 /// clear all of the cached analysis results that are keyed on the \c
133 /// LoopInfo for this function.
136
137private:
138 LoopAnalysisManager *InnerAM;
139 LoopInfo *LI;
140 bool MSSAUsed = false;
141};
142
143/// Provide a specialized run method for the \c LoopAnalysisManagerFunctionProxy
144/// so it can pass the \c LoopInfo to the result.
145template <>
148
149// Ensure the \c LoopAnalysisManagerFunctionProxy is provided as an extern
150// template.
152
155/// A proxy from a \c FunctionAnalysisManager to a \c Loop.
159
160/// Returns the minimum set of Analyses that all loop passes must preserve.
162}
163
164#endif // LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
early cse Early CSE w MemorySSA
Definition: EarlyCSE.cpp:1948
#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: Analysis.h:49
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:292
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
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:162
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:563
Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
Definition: PassManager.h:624
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:44
Encapsulates MemorySSA, including all data associated with memory accesses.
Definition: MemorySSA.h:701
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Definition: PassManager.h:688
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:111
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:542
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:1849
PreservedAnalyses getLoopPassPreservedAnalyses()
Returns the minimum set of Analyses that all loop passes must preserve.
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...