Coverage Report

Created: 2018-09-25 17:16

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Analysis/LazyValueInfo.h
Line
Count
Source (jump to first uncovered line)
1
//===- LazyValueInfo.h - Value constraint analysis --------------*- 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
//
10
// This file defines the interface for lazy computation of value constraint
11
// information.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_ANALYSIS_LAZYVALUEINFO_H
16
#define LLVM_ANALYSIS_LAZYVALUEINFO_H
17
18
#include "llvm/IR/PassManager.h"
19
#include "llvm/Pass.h"
20
21
namespace llvm {
22
  class AssumptionCache;
23
  class Constant;
24
  class ConstantRange;
25
  class DataLayout;
26
  class DominatorTree;
27
  class Instruction;
28
  class TargetLibraryInfo;
29
  class Value;
30
31
/// This pass computes, caches, and vends lazy value constraint information.
32
class LazyValueInfo {
33
  friend class LazyValueInfoWrapperPass;
34
  AssumptionCache *AC = nullptr;
35
  const DataLayout *DL = nullptr;
36
  class TargetLibraryInfo *TLI = nullptr;
37
  DominatorTree *DT = nullptr;
38
  void *PImpl = nullptr;
39
  LazyValueInfo(const LazyValueInfo&) = delete;
40
  void operator=(const LazyValueInfo&) = delete;
41
public:
42
  ~LazyValueInfo();
43
26.7k
  LazyValueInfo() {}
44
  LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_, TargetLibraryInfo *TLI_,
45
                DominatorTree *DT_)
46
250
      : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {}
47
  LazyValueInfo(LazyValueInfo &&Arg)
48
500
      : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) {
49
500
    Arg.PImpl = nullptr;
50
500
  }
51
0
  LazyValueInfo &operator=(LazyValueInfo &&Arg) {
52
0
    releaseMemory();
53
0
    AC = Arg.AC;
54
0
    DL = Arg.DL;
55
0
    TLI = Arg.TLI;
56
0
    DT = Arg.DT;
57
0
    PImpl = Arg.PImpl;
58
0
    Arg.PImpl = nullptr;
59
0
    return *this;
60
0
  }
61
62
  /// This is used to return true/false/dunno results.
63
  enum Tristate {
64
    Unknown = -1, False = 0, True = 1
65
  };
66
67
  // Public query interface.
68
69
  /// Determine whether the specified value comparison with a constant is known
70
  /// to be true or false on the specified CFG edge.
71
  /// Pred is a CmpInst predicate.
72
  Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
73
                              BasicBlock *FromBB, BasicBlock *ToBB,
74
                              Instruction *CxtI = nullptr);
75
76
  /// Determine whether the specified value comparison with a constant is known
77
  /// to be true or false at the specified instruction
78
  /// (from an assume intrinsic). Pred is a CmpInst predicate.
79
  Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
80
                          Instruction *CxtI);
81
82
  /// Determine whether the specified value is known to be a
83
  /// constant at the end of the specified block.  Return null if not.
84
  Constant *getConstant(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
85
86
  /// Return the ConstantRange constraint that is known to hold for the
87
  /// specified value at the end of the specified block. This may only be called
88
  /// on integer-typed Values.
89
  ConstantRange getConstantRange(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
90
91
  /// Determine whether the specified value is known to be a
92
  /// constant on the specified edge.  Return null if not.
93
  Constant *getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
94
                              Instruction *CxtI = nullptr);
95
96
  /// Return the ConstantRage constraint that is known to hold for the
97
  /// specified value on the specified edge. This may be only be called
98
  /// on integer-typed Values.
99
  ConstantRange getConstantRangeOnEdge(Value *V, BasicBlock *FromBB,
100
                                       BasicBlock *ToBB,
101
                                       Instruction *CxtI = nullptr);
102
103
  /// Inform the analysis cache that we have threaded an edge from
104
  /// PredBB to OldSucc to be from PredBB to NewSucc instead.
105
  void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc);
106
107
  /// Inform the analysis cache that we have erased a block.
108
  void eraseBlock(BasicBlock *BB);
109
110
  /// Print the \LazyValueInfo Analysis.
111
  /// We pass in the DTree that is required for identifying which basic blocks
112
  /// we can solve/print for, in the LVIPrinter. The DT is optional
113
  /// in LVI, so we need to pass it here as an argument.
114
  void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
115
116
  /// Disables use of the DominatorTree within LVI.
117
  void disableDT();
118
119
  /// Enables use of the DominatorTree within LVI. Does nothing if the class
120
  /// instance was initialized without a DT pointer.
121
  void enableDT();
122
123
  // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
124
  void releaseMemory();
125
126
  /// Handle invalidation events in the new pass manager.
127
  bool invalidate(Function &F, const PreservedAnalyses &PA,
128
                  FunctionAnalysisManager::Invalidator &Inv);
129
};
130
131
/// Analysis to compute lazy value information.
132
class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
133
public:
134
  typedef LazyValueInfo Result;
135
  Result run(Function &F, FunctionAnalysisManager &FAM);
136
137
private:
138
  static AnalysisKey Key;
139
  friend struct AnalysisInfoMixin<LazyValueAnalysis>;
140
};
141
142
/// Wrapper around LazyValueInfo.
143
class LazyValueInfoWrapperPass : public FunctionPass {
144
  LazyValueInfoWrapperPass(const LazyValueInfoWrapperPass&) = delete;
145
  void operator=(const LazyValueInfoWrapperPass&) = delete;
146
public:
147
  static char ID;
148
26.7k
  LazyValueInfoWrapperPass() : FunctionPass(ID) {
149
26.7k
    initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
150
26.7k
  }
151
26.7k
  ~LazyValueInfoWrapperPass() override {
152
26.7k
    assert(!Info.PImpl && "releaseMemory not called");
153
26.7k
  }
154
155
  LazyValueInfo &getLVI();
156
157
  void getAnalysisUsage(AnalysisUsage &AU) const override;
158
  void releaseMemory() override;
159
  bool runOnFunction(Function &F) override;
160
private:
161
  LazyValueInfo Info;
162
};
163
164
}  // end namespace llvm
165
166
#endif
167