Coverage Report

Created: 2018-11-16 02:38

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/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/MemorySSA.h"
41
#include "llvm/Analysis/ScalarEvolution.h"
42
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
43
#include "llvm/Analysis/TargetLibraryInfo.h"
44
#include "llvm/Analysis/TargetTransformInfo.h"
45
#include "llvm/IR/Dominators.h"
46
#include "llvm/IR/PassManager.h"
47
48
namespace llvm {
49
50
/// The adaptor from a function pass to a loop pass computes these analyses and
51
/// makes them available to the loop passes "for free". Each loop pass is
52
/// expected expected to update these analyses if necessary to ensure they're
53
/// valid after it runs.
54
struct LoopStandardAnalysisResults {
55
  AAResults &AA;
56
  AssumptionCache ∾
57
  DominatorTree &DT;
58
  LoopInfo &LI;
59
  ScalarEvolution &SE;
60
  TargetLibraryInfo &TLI;
61
  TargetTransformInfo &TTI;
62
  MemorySSA *MSSA;
63
};
64
65
/// Enables memory ssa as a dependency for loop passes.
66
extern cl::opt<bool> EnableMSSALoopDependency;
67
68
/// Extern template declaration for the analysis set for this IR unit.
69
extern template class AllAnalysesOn<Loop>;
70
71
extern template class AnalysisManager<Loop, LoopStandardAnalysisResults &>;
72
/// The loop analysis manager.
73
///
74
/// See the documentation for the AnalysisManager template for detail
75
/// documentation. This typedef serves as a convenient way to refer to this
76
/// construct in the adaptors and proxies used to integrate this into the larger
77
/// pass manager infrastructure.
78
typedef AnalysisManager<Loop, LoopStandardAnalysisResults &>
79
    LoopAnalysisManager;
80
81
/// A proxy from a \c LoopAnalysisManager to a \c Function.
82
typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function>
83
    LoopAnalysisManagerFunctionProxy;
84
85
/// A specialized result for the \c LoopAnalysisManagerFunctionProxy which
86
/// retains a \c LoopInfo reference.
87
///
88
/// This allows it to collect loop objects for which analysis results may be
89
/// cached in the \c LoopAnalysisManager.
90
template <> class LoopAnalysisManagerFunctionProxy::Result {
91
public:
92
  explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
93
830
      : InnerAM(&InnerAM), LI(&LI) {}
94
1.66k
  Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI) {
95
1.66k
    // We have to null out the analysis manager in the moved-from state
96
1.66k
    // because we are taking ownership of the responsibilty to clear the
97
1.66k
    // analysis state.
98
1.66k
    Arg.InnerAM = nullptr;
99
1.66k
  }
100
0
  Result &operator=(Result &&RHS) {
101
0
    InnerAM = RHS.InnerAM;
102
0
    LI = RHS.LI;
103
0
    // We have to null out the analysis manager in the moved-from state
104
0
    // because we are taking ownership of the responsibilty to clear the
105
0
    // analysis state.
106
0
    RHS.InnerAM = nullptr;
107
0
    return *this;
108
0
  }
109
2.49k
  ~Result() {
110
2.49k
    // InnerAM is cleared in a moved from state where there is nothing to do.
111
2.49k
    if (!InnerAM)
112
1.74k
      return;
113
750
114
750
    // Clear out the analysis manager if we're being destroyed -- it means we
115
750
    // didn't even see an invalidate call when we got invalidated.
116
750
    InnerAM->clear();
117
750
  }
118
119
  /// Accessor for the analysis manager.
120
1.28k
  LoopAnalysisManager &getManager() { return *InnerAM; }
121
122
  /// Handler for invalidation of the proxy for a particular function.
123
  ///
124
  /// If the proxy, \c LoopInfo, and associated analyses are preserved, this
125
  /// will merely forward the invalidation event to any cached loop analysis
126
  /// results for loops within this function.
127
  ///
128
  /// If the necessary loop infrastructure is not preserved, this will forcibly
129
  /// clear all of the cached analysis results that are keyed on the \c
130
  /// LoopInfo for this function.
131
  bool invalidate(Function &F, const PreservedAnalyses &PA,
132
                  FunctionAnalysisManager::Invalidator &Inv);
133
134
private:
135
  LoopAnalysisManager *InnerAM;
136
  LoopInfo *LI;
137
};
138
139
/// Provide a specialized run method for the \c LoopAnalysisManagerFunctionProxy
140
/// so it can pass the \c LoopInfo to the result.
141
template <>
142
LoopAnalysisManagerFunctionProxy::Result
143
LoopAnalysisManagerFunctionProxy::run(Function &F, FunctionAnalysisManager &AM);
144
145
// Ensure the \c LoopAnalysisManagerFunctionProxy is provided as an extern
146
// template.
147
extern template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
148
149
extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
150
                                                LoopStandardAnalysisResults &>;
151
/// A proxy from a \c FunctionAnalysisManager to a \c Loop.
152
typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
153
                                  LoopStandardAnalysisResults &>
154
    FunctionAnalysisManagerLoopProxy;
155
156
/// Returns the minimum set of Analyses that all loop passes must preserve.
157
PreservedAnalyses getLoopPassPreservedAnalyses();
158
}
159
160
#endif // LLVM_ANALYSIS_LOOPANALYSISMANAGER_H