LLVM  9.0.0svn
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 
34 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/Analysis/LoopInfo.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.
62 };
63 
64 /// Enables memory ssa as a dependency for loop passes.
66 
67 /// Extern template declaration for the analysis set for this IR unit.
68 extern template class AllAnalysesOn<Loop>;
69 
71 /// The loop analysis manager.
72 ///
73 /// See the documentation for the AnalysisManager template for detail
74 /// documentation. This typedef serves as a convenient way to refer to this
75 /// construct in the adaptors and proxies used to integrate this into the larger
76 /// pass manager infrastructure.
79 
80 /// A proxy from a \c LoopAnalysisManager to a \c Function.
83 
84 /// A specialized result for the \c LoopAnalysisManagerFunctionProxy which
85 /// retains a \c LoopInfo reference.
86 ///
87 /// This allows it to collect loop objects for which analysis results may be
88 /// cached in the \c LoopAnalysisManager.
90 public:
91  explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
92  : InnerAM(&InnerAM), LI(&LI) {}
93  Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI) {
94  // We have to null out the analysis manager in the moved-from state
95  // because we are taking ownership of the responsibilty to clear the
96  // analysis state.
97  Arg.InnerAM = nullptr;
98  }
100  InnerAM = RHS.InnerAM;
101  LI = RHS.LI;
102  // We have to null out the analysis manager in the moved-from state
103  // because we are taking ownership of the responsibilty to clear the
104  // analysis state.
105  RHS.InnerAM = nullptr;
106  return *this;
107  }
109  // InnerAM is cleared in a moved from state where there is nothing to do.
110  if (!InnerAM)
111  return;
112 
113  // Clear out the analysis manager if we're being destroyed -- it means we
114  // didn't even see an invalidate call when we got invalidated.
115  InnerAM->clear();
116  }
117 
118  /// Accessor for the analysis manager.
119  LoopAnalysisManager &getManager() { return *InnerAM; }
120 
121  /// Handler for invalidation of the proxy for a particular function.
122  ///
123  /// If the proxy, \c LoopInfo, and associated analyses are preserved, this
124  /// will merely forward the invalidation event to any cached loop analysis
125  /// results for loops within this function.
126  ///
127  /// If the necessary loop infrastructure is not preserved, this will forcibly
128  /// clear all of the cached analysis results that are keyed on the \c
129  /// LoopInfo for this function.
130  bool invalidate(Function &F, const PreservedAnalyses &PA,
132 
133 private:
134  LoopAnalysisManager *InnerAM;
135  LoopInfo *LI;
136 };
137 
138 /// Provide a specialized run method for the \c LoopAnalysisManagerFunctionProxy
139 /// so it can pass the \c LoopInfo to the result.
140 template <>
143 
144 // Ensure the \c LoopAnalysisManagerFunctionProxy is provided as an extern
145 // template.
147 
150 /// A proxy from a \c FunctionAnalysisManager to a \c Loop.
152  LoopStandardAnalysisResults &>
154 
155 /// Returns the minimum set of Analyses that all loop passes must preserve.
157 }
158 
159 #endif // LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
This file provides a priority worklist.
LoopAnalysisManager & getManager()
Accessor for the analysis manager.
PreservedAnalyses getLoopPassPreservedAnalyses()
Returns the minimum set of Analyses that all loop passes must preserve.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
This is the interface for a simple mod/ref and alias analysis over globals.
InnerAnalysisManagerProxy< LoopAnalysisManager, Function > LoopAnalysisManagerFunctionProxy
A proxy from a LoopAnalysisManager to a Function.
The main scalar evolution driver.
A cache of @llvm.assume calls within a function.
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
F(f)
Definition: BitVector.h:937
This is the interface for a SCEV-based alias analysis.
Encapsulates MemorySSA, including all data associated with memory accesses.
Definition: MemorySSA.h:700
Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:144
A specialized result for the LoopAnalysisManagerFunctionProxy which retains a LoopInfo reference...
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition: PassManager.h:1018
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Definition: PassManager.h:1153
Provides information about what library functions are available for the current target.
Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
Definition: PassManager.h:1100
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:464
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:641
This templated class represents "all analyses that operate over <a particular IR unit>" (e...
Definition: PassManager.h:91
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
This is the interface for LLVM&#39;s primary stateless and local alias analysis.
A container for analyses that lazily runs them and caches their results.
This pass exposes codegen information to IR-level passes.
This header defines various interfaces for pass management in LLVM.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:1037
cl::opt< bool > EnableMSSALoopDependency
Enables memory ssa as a dependency for loop passes.