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.
51struct LoopStandardAnalysisResults {
52 AAResults &AA;
53 AssumptionCache ∾
54 DominatorTree &DT;
55 LoopInfo &LI;
56 ScalarEvolution &SE;
57 TargetLibraryInfo &TLI;
58 TargetTransformInfo &TTI;
59 BlockFrequencyInfo *BFI;
60 BranchProbabilityInfo *BPI;
61 MemorySSA *MSSA;
62};
63
64/// Extern template declaration for the analysis set for this IR unit.
65extern template class AllAnalysesOn<Loop>;
66
67extern template class AnalysisManager<Loop, LoopStandardAnalysisResults &>;
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.
74typedef AnalysisManager<Loop, LoopStandardAnalysisResults &>
75 LoopAnalysisManager;
76
77/// A proxy from a \c LoopAnalysisManager to a \c Function.
78typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function>
79 LoopAnalysisManagerFunctionProxy;
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.
86template <> class LoopAnalysisManagerFunctionProxy::Result {
87public:
88 explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
89 : InnerAM(&InnerAM), LI(&LI) {}
90 Result(Result &&Arg)
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 }
97 Result &operator=(Result &&RHS) {
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 }
107 ~Result() {
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,
133 FunctionAnalysisManager::Invalidator &Inv);
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 <>
144LoopAnalysisManagerFunctionProxy::Result
145LoopAnalysisManagerFunctionProxy::run(Function &F, FunctionAnalysisManager &AM);
146
147// Ensure the \c LoopAnalysisManagerFunctionProxy is provided as an extern
148// template.
149extern template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
150
151extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
152 LoopStandardAnalysisResults &>;
153/// A proxy from a \c FunctionAnalysisManager to a \c Loop.
154typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
155 LoopStandardAnalysisResults &>
156 FunctionAnalysisManagerLoopProxy;
157
158/// Returns the minimum set of Analyses that all loop passes must preserve.
159PreservedAnalyses getLoopPassPreservedAnalyses();
160}
161
162#endif // LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
163

source code of llvm/include/llvm/Analysis/LoopAnalysisManager.h