/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Analysis/LoopAnalysisManager.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- LoopAnalysisManager.h - Loop analysis management ---------*- C++ -*-===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | /// \file |
10 | | /// |
11 | | /// This header provides classes for managing per-loop analyses. These are |
12 | | /// typically used as part of a loop pass pipeline over the loop nests of |
13 | | /// a function. |
14 | | /// |
15 | | /// Loop analyses are allowed to make some simplifying assumptions: |
16 | | /// 1) Loops are, where possible, in simplified form. |
17 | | /// 2) Loops are *always* in LCSSA form. |
18 | | /// 3) A collection of analysis results are available: |
19 | | /// - LoopInfo |
20 | | /// - DominatorTree |
21 | | /// - ScalarEvolution |
22 | | /// - AAManager |
23 | | /// |
24 | | /// The primary mechanism to provide these invariants is the loop pass manager, |
25 | | /// but they can also be manually provided in order to reason about a loop from |
26 | | /// outside of a dedicated pass manager. |
27 | | /// |
28 | | //===----------------------------------------------------------------------===// |
29 | | |
30 | | #ifndef LLVM_ANALYSIS_LOOPANALYSISMANAGER_H |
31 | | #define LLVM_ANALYSIS_LOOPANALYSISMANAGER_H |
32 | | |
33 | | #include "llvm/ADT/PostOrderIterator.h" |
34 | | #include "llvm/ADT/PriorityWorklist.h" |
35 | | #include "llvm/ADT/STLExtras.h" |
36 | | #include "llvm/Analysis/AliasAnalysis.h" |
37 | | #include "llvm/Analysis/BasicAliasAnalysis.h" |
38 | | #include "llvm/Analysis/GlobalsModRef.h" |
39 | | #include "llvm/Analysis/LoopInfo.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 | | |
47 | | namespace 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. |
53 | | struct LoopStandardAnalysisResults { |
54 | | AAResults &AA; |
55 | | AssumptionCache ∾ |
56 | | DominatorTree &DT; |
57 | | LoopInfo &LI; |
58 | | ScalarEvolution &SE; |
59 | | TargetLibraryInfo &TLI; |
60 | | TargetTransformInfo &TTI; |
61 | | }; |
62 | | |
63 | | /// Extern template declaration for the analysis set for this IR unit. |
64 | | extern template class AllAnalysesOn<Loop>; |
65 | | |
66 | | extern template class AnalysisManager<Loop, LoopStandardAnalysisResults &>; |
67 | | /// \brief The loop analysis manager. |
68 | | /// |
69 | | /// See the documentation for the AnalysisManager template for detail |
70 | | /// documentation. This typedef serves as a convenient way to refer to this |
71 | | /// construct in the adaptors and proxies used to integrate this into the larger |
72 | | /// pass manager infrastructure. |
73 | | typedef AnalysisManager<Loop, LoopStandardAnalysisResults &> |
74 | | LoopAnalysisManager; |
75 | | |
76 | | /// A proxy from a \c LoopAnalysisManager to a \c Function. |
77 | | typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function> |
78 | | LoopAnalysisManagerFunctionProxy; |
79 | | |
80 | | /// A specialized result for the \c LoopAnalysisManagerFunctionProxy which |
81 | | /// retains a \c LoopInfo reference. |
82 | | /// |
83 | | /// This allows it to collect loop objects for which analysis results may be |
84 | | /// cached in the \c LoopAnalysisManager. |
85 | | template <> class LoopAnalysisManagerFunctionProxy::Result { |
86 | | public: |
87 | | explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI) |
88 | 453 | : InnerAM(&InnerAM), LI(&LI) {} |
89 | 906 | Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI) { |
90 | 906 | // We have to null out the analysis manager in the moved-from state |
91 | 906 | // because we are taking ownership of the responsibilty to clear the |
92 | 906 | // analysis state. |
93 | 906 | Arg.InnerAM = nullptr; |
94 | 906 | } |
95 | 0 | Result &operator=(Result &&RHS) { |
96 | 0 | InnerAM = RHS.InnerAM; |
97 | 0 | LI = RHS.LI; |
98 | 0 | // We have to null out the analysis manager in the moved-from state |
99 | 0 | // because we are taking ownership of the responsibilty to clear the |
100 | 0 | // analysis state. |
101 | 0 | RHS.InnerAM = nullptr; |
102 | 0 | return *this; |
103 | 0 | } |
104 | 1.35k | ~Result() { |
105 | 1.35k | // InnerAM is cleared in a moved from state where there is nothing to do. |
106 | 1.35k | if (!InnerAM) |
107 | 980 | return; |
108 | 1.35k | |
109 | 1.35k | // Clear out the analysis manager if we're being destroyed -- it means we |
110 | 1.35k | // didn't even see an invalidate call when we got invalidated. |
111 | 379 | InnerAM->clear(); |
112 | 379 | } |
113 | | |
114 | | /// Accessor for the analysis manager. |
115 | 803 | LoopAnalysisManager &getManager() { return *InnerAM; } |
116 | | |
117 | | /// Handler for invalidation of the proxy for a particular function. |
118 | | /// |
119 | | /// If the proxy, \c LoopInfo, and associated analyses are preserved, this |
120 | | /// will merely forward the invalidation event to any cached loop analysis |
121 | | /// results for loops within this function. |
122 | | /// |
123 | | /// If the necessary loop infrastructure is not preserved, this will forcibly |
124 | | /// clear all of the cached analysis results that are keyed on the \c |
125 | | /// LoopInfo for this function. |
126 | | bool invalidate(Function &F, const PreservedAnalyses &PA, |
127 | | FunctionAnalysisManager::Invalidator &Inv); |
128 | | |
129 | | private: |
130 | | LoopAnalysisManager *InnerAM; |
131 | | LoopInfo *LI; |
132 | | }; |
133 | | |
134 | | /// Provide a specialized run method for the \c LoopAnalysisManagerFunctionProxy |
135 | | /// so it can pass the \c LoopInfo to the result. |
136 | | template <> |
137 | | LoopAnalysisManagerFunctionProxy::Result |
138 | | LoopAnalysisManagerFunctionProxy::run(Function &F, FunctionAnalysisManager &AM); |
139 | | |
140 | | // Ensure the \c LoopAnalysisManagerFunctionProxy is provided as an extern |
141 | | // template. |
142 | | extern template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>; |
143 | | |
144 | | extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop, |
145 | | LoopStandardAnalysisResults &>; |
146 | | /// A proxy from a \c FunctionAnalysisManager to a \c Loop. |
147 | | typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop, |
148 | | LoopStandardAnalysisResults &> |
149 | | FunctionAnalysisManagerLoopProxy; |
150 | | |
151 | | /// Returns the minimum set of Analyses that all loop passes must preserve. |
152 | | PreservedAnalyses getLoopPassPreservedAnalyses(); |
153 | | } |
154 | | |
155 | | #endif // LLVM_ANALYSIS_LOOPANALYSISMANAGER_H |