LoopAnalysisManager.h revision 360784 
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/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"
46
47namespace llvm {
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 expected to update these analyses if necessary to ensure they're
52/// valid after it runs.
53struct LoopStandardAnalysisResults {
54  AAResults &AA;
55  AssumptionCache ∾
56  DominatorTree &DT;
57  LoopInfo &LI;
58  ScalarEvolution &SE;
59  TargetLibraryInfo &TLI;
60  TargetTransformInfo &TTI;
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), MSSAUsed(false) {}
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;
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