Line data Source code
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 3476 : LazyValueInfo() {}
44 : LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_, TargetLibraryInfo *TLI_,
45 : DominatorTree *DT_)
46 261 : : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {}
47 : LazyValueInfo(LazyValueInfo &&Arg)
48 522 : : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) {
49 261 : Arg.PImpl = nullptr;
50 : }
51 : LazyValueInfo &operator=(LazyValueInfo &&Arg) {
52 : releaseMemory();
53 : AC = Arg.AC;
54 : DL = Arg.DL;
55 : TLI = Arg.TLI;
56 : DT = Arg.DT;
57 : PImpl = Arg.PImpl;
58 : Arg.PImpl = nullptr;
59 : return *this;
60 : }
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 3476 : LazyValueInfoWrapperPass() : FunctionPass(ID) {
149 3476 : initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
150 3476 : }
151 3460 : ~LazyValueInfoWrapperPass() override {
152 : assert(!Info.PImpl && "releaseMemory not called");
153 3460 : }
154 3460 :
155 : LazyValueInfo &getLVI();
156 3460 :
157 0 : void getAnalysisUsage(AnalysisUsage &AU) const override;
158 : void releaseMemory() override;
159 0 : bool runOnFunction(Function &F) override;
160 : private:
161 : LazyValueInfo Info;
162 : };
163 :
164 : } // end namespace llvm
165 :
166 : #endif
167 :
|
