1 //===- LoopAnalysisManager.h - Loop analysis management ---------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
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
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:
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.
27 //===----------------------------------------------------------------------===//
29 #ifndef LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
30 #define LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
32 #include "llvm/ADT/PostOrderIterator.h"
33 #include "llvm/ADT/PriorityWorklist.h"
34 #include "llvm/ADT/STLExtras.h"
35 #include "llvm/Analysis/AliasAnalysis.h"
36 #include "llvm/Analysis/BasicAliasAnalysis.h"
37 #include "llvm/Analysis/GlobalsModRef.h"
38 #include "llvm/Analysis/LoopInfo.h"
39 #include "llvm/Analysis/MemorySSA.h"
40 #include "llvm/Analysis/ScalarEvolution.h"
41 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
42 #include "llvm/Analysis/TargetLibraryInfo.h"
43 #include "llvm/Analysis/TargetTransformInfo.h"
44 #include "llvm/IR/Dominators.h"
45 #include "llvm/IR/PassManager.h"
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 expected to update these analyses if necessary to ensure they're
52 /// valid after it runs.
53 struct LoopStandardAnalysisResults {
59 TargetLibraryInfo &TLI;
60 TargetTransformInfo &TTI;
64 /// Extern template declaration for the analysis set for this IR unit.
65 extern template class AllAnalysesOn<Loop>;
67 extern template class AnalysisManager<Loop, LoopStandardAnalysisResults &>;
68 /// The loop analysis manager.
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.
74 typedef AnalysisManager<Loop, LoopStandardAnalysisResults &>
77 /// A proxy from a \c LoopAnalysisManager to a \c Function.
78 typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function>
79 LoopAnalysisManagerFunctionProxy;
81 /// A specialized result for the \c LoopAnalysisManagerFunctionProxy which
82 /// retains a \c LoopInfo reference.
84 /// This allows it to collect loop objects for which analysis results may be
85 /// cached in the \c LoopAnalysisManager.
86 template <> class LoopAnalysisManagerFunctionProxy::Result {
88 explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
89 : InnerAM(&InnerAM), LI(&LI) {}
90 Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI) {
91 // We have to null out the analysis manager in the moved-from state
92 // because we are taking ownership of the responsibilty to clear the
94 Arg.InnerAM = nullptr;
96 Result &operator=(Result &&RHS) {
97 InnerAM = RHS.InnerAM;
99 // We have to null out the analysis manager in the moved-from state
100 // because we are taking ownership of the responsibilty to clear the
102 RHS.InnerAM = nullptr;
106 // InnerAM is cleared in a moved from state where there is nothing to do.
110 // Clear out the analysis manager if we're being destroyed -- it means we
111 // didn't even see an invalidate call when we got invalidated.
115 /// Accessor for the analysis manager.
116 LoopAnalysisManager &getManager() { return *InnerAM; }
118 /// Handler for invalidation of the proxy for a particular function.
120 /// If the proxy, \c LoopInfo, and associated analyses are preserved, this
121 /// will merely forward the invalidation event to any cached loop analysis
122 /// results for loops within this function.
124 /// If the necessary loop infrastructure is not preserved, this will forcibly
125 /// clear all of the cached analysis results that are keyed on the \c
126 /// LoopInfo for this function.
127 bool invalidate(Function &F, const PreservedAnalyses &PA,
128 FunctionAnalysisManager::Invalidator &Inv);
131 LoopAnalysisManager *InnerAM;
135 /// Provide a specialized run method for the \c LoopAnalysisManagerFunctionProxy
136 /// so it can pass the \c LoopInfo to the result.
138 LoopAnalysisManagerFunctionProxy::Result
139 LoopAnalysisManagerFunctionProxy::run(Function &F, FunctionAnalysisManager &AM);
141 // Ensure the \c LoopAnalysisManagerFunctionProxy is provided as an extern
143 extern template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
145 extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
146 LoopStandardAnalysisResults &>;
147 /// A proxy from a \c FunctionAnalysisManager to a \c Loop.
148 typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
149 LoopStandardAnalysisResults &>
150 FunctionAnalysisManagerLoopProxy;
152 /// Returns the minimum set of Analyses that all loop passes must preserve.
153 PreservedAnalyses getLoopPassPreservedAnalyses();
156 #endif // LLVM_ANALYSIS_LOOPANALYSISMANAGER_H