LLVM  16.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 
34 namespace llvm {
35 
36 class AAResults;
37 class AssumptionCache;
38 class DominatorTree;
39 class Function;
40 class Loop;
41 class LoopInfo;
42 class MemorySSA;
43 class ScalarEvolution;
44 class TargetLibraryInfo;
45 class 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.
65 extern 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.
87 public:
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.
132  bool invalidate(Function &F, const PreservedAnalyses &PA,
134 
135 private:
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.
143 template <>
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
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
llvm::OuterAnalysisManagerProxy
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Definition: PassManager.h:1056
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::LoopStandardAnalysisResults::AC
AssumptionCache & AC
Definition: LoopAnalysisManager.h:53
llvm::Function
Definition: Function.h:60
llvm::Loop
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:546
llvm::LoopAnalysisManagerFunctionProxy::Result::Result
Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
Definition: LoopAnalysisManager.h:88
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:172
llvm::InnerAnalysisManagerProxy::Result
Definition: PassManager.h:935
llvm::AllAnalysesOn
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
Definition: PassManager.h:90
llvm::ScalarEvolution
The main scalar evolution driver.
Definition: ScalarEvolution.h:449
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
llvm::LoopAnalysisManagerFunctionProxy::Result::~Result
~Result()
Definition: LoopAnalysisManager.h:107
llvm::LoopStandardAnalysisResults
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
Definition: LoopAnalysisManager.h:51
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::LoopStandardAnalysisResults::DT
DominatorTree & DT
Definition: LoopAnalysisManager.h:54
F
#define F(x, y, z)
Definition: MD5.cpp:55
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:187
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
llvm::AAResults
Definition: AliasAnalysis.h:518
llvm::BranchProbabilityInfo
Analysis providing branch probability information.
Definition: BranchProbabilityInfo.h:113
llvm::LoopStandardAnalysisResults::BPI
BranchProbabilityInfo * BPI
Definition: LoopAnalysisManager.h:60
llvm::LoopAnalysisManagerFunctionProxy::Result::getManager
LoopAnalysisManager & getManager()
Accessor for the analysis manager.
Definition: LoopAnalysisManager.h:121
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:661
llvm::getLoopPassPreservedAnalyses
PreservedAnalyses getLoopPassPreservedAnalyses()
Returns the minimum set of Analyses that all loop passes must preserve.
Definition: LoopAnalysisManager.cpp:137
llvm::MemorySSA
Encapsulates MemorySSA, including all data associated with memory accesses.
Definition: MemorySSA.h:700
llvm::move
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:1666
llvm::FunctionAnalysisManagerLoopProxy
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
Definition: LoopAnalysisManager.h:156
llvm::LoopAnalysisManagerFunctionProxy::Result::operator=
Result & operator=(Result &&RHS)
Definition: LoopAnalysisManager.h:97
llvm::LoopInfo
Definition: LoopInfo.h:1105
llvm::AssumptionCache
A cache of @llvm.assume calls within a function.
Definition: AssumptionCache.h:42
llvm::LoopAnalysisManagerFunctionProxy
InnerAnalysisManagerProxy< LoopAnalysisManager, Function > LoopAnalysisManagerFunctionProxy
A proxy from a LoopAnalysisManager to a Function.
Definition: LoopAnalysisManager.h:79
llvm::LoopStandardAnalysisResults::LI
LoopInfo & LI
Definition: LoopAnalysisManager.h:55
llvm::LoopStandardAnalysisResults::BFI
BlockFrequencyInfo * BFI
Definition: LoopAnalysisManager.h:59
std
Definition: BitVector.h:851
llvm::LoopStandardAnalysisResults::TTI
TargetTransformInfo & TTI
Definition: LoopAnalysisManager.h:58
llvm::LoopAnalysisManagerFunctionProxy::Result::markMSSAUsed
void markMSSAUsed()
Mark MemorySSA as used so we can invalidate self if MSSA is invalidated.
Definition: LoopAnalysisManager.h:118
PassManager.h
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:222
llvm::LoopStandardAnalysisResults::SE
ScalarEvolution & SE
Definition: LoopAnalysisManager.h:56
llvm::LoopStandardAnalysisResults::AA
AAResults & AA
Definition: LoopAnalysisManager.h:52
llvm::LoopAnalysisManagerFunctionProxy::Result::Result
Result(Result &&Arg)
Definition: LoopAnalysisManager.h:90
llvm::LoopAnalysisManagerFunctionProxy::Result
A specialized result for the LoopAnalysisManagerFunctionProxy which retains a LoopInfo reference.
Definition: LoopAnalysisManager.h:86
llvm::FunctionAnalysisManager
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition: PassManager.h:912
llvm::LoopAnalysisManager
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
Definition: LoopAnalysisManager.h:75
llvm::LoopStandardAnalysisResults::MSSA
MemorySSA * MSSA
Definition: LoopAnalysisManager.h:61
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::InnerAnalysisManagerProxy
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:931
llvm::InnerAnalysisManagerProxy::run
Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
Definition: PassManager.h:994
MemorySSA
early cse Early CSE w MemorySSA
Definition: EarlyCSE.cpp:1790
llvm::LoopStandardAnalysisResults::TLI
TargetLibraryInfo & TLI
Definition: LoopAnalysisManager.h:57
llvm::codeview::PublicSymFlags::Function
@ Function