LLVM  9.0.0svn
LazyValueInfo.h
Go to the documentation of this file.
1 //===- LazyValueInfo.h - Value constraint analysis --------------*- 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 //
9 // This file defines the interface for lazy computation of value constraint
10 // information.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_ANALYSIS_LAZYVALUEINFO_H
15 #define LLVM_ANALYSIS_LAZYVALUEINFO_H
16 
17 #include "llvm/IR/PassManager.h"
18 #include "llvm/Pass.h"
19 
20 namespace llvm {
21  class AssumptionCache;
22  class Constant;
23  class ConstantRange;
24  class DataLayout;
25  class DominatorTree;
26  class Instruction;
27  class TargetLibraryInfo;
28  class Value;
29 
30 /// This pass computes, caches, and vends lazy value constraint information.
33  AssumptionCache *AC = nullptr;
34  const DataLayout *DL = nullptr;
35  class TargetLibraryInfo *TLI = nullptr;
36  DominatorTree *DT = nullptr;
37  void *PImpl = nullptr;
38  LazyValueInfo(const LazyValueInfo&) = delete;
39  void operator=(const LazyValueInfo&) = delete;
40 public:
44  DominatorTree *DT_)
45  : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {}
47  : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) {
48  Arg.PImpl = nullptr;
49  }
51  releaseMemory();
52  AC = Arg.AC;
53  DL = Arg.DL;
54  TLI = Arg.TLI;
55  DT = Arg.DT;
56  PImpl = Arg.PImpl;
57  Arg.PImpl = nullptr;
58  return *this;
59  }
60 
61  /// This is used to return true/false/dunno results.
62  enum Tristate {
63  Unknown = -1, False = 0, True = 1
64  };
65 
66  // Public query interface.
67 
68  /// Determine whether the specified value comparison with a constant is known
69  /// to be true or false on the specified CFG edge.
70  /// Pred is a CmpInst predicate.
71  Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
72  BasicBlock *FromBB, BasicBlock *ToBB,
73  Instruction *CxtI = nullptr);
74 
75  /// Determine whether the specified value comparison with a constant is known
76  /// to be true or false at the specified instruction
77  /// (from an assume intrinsic). Pred is a CmpInst predicate.
78  Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
79  Instruction *CxtI);
80 
81  /// Determine whether the specified value is known to be a
82  /// constant at the end of the specified block. Return null if not.
83  Constant *getConstant(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
84 
85  /// Return the ConstantRange constraint that is known to hold for the
86  /// specified value at the end of the specified block. This may only be called
87  /// on integer-typed Values.
88  ConstantRange getConstantRange(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
89 
90  /// Determine whether the specified value is known to be a
91  /// constant on the specified edge. Return null if not.
93  Instruction *CxtI = nullptr);
94 
95  /// Return the ConstantRage constraint that is known to hold for the
96  /// specified value on the specified edge. This may be only be called
97  /// on integer-typed Values.
99  BasicBlock *ToBB,
100  Instruction *CxtI = nullptr);
101 
102  /// Inform the analysis cache that we have threaded an edge from
103  /// PredBB to OldSucc to be from PredBB to NewSucc instead.
104  void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc);
105 
106  /// Inform the analysis cache that we have erased a block.
107  void eraseBlock(BasicBlock *BB);
108 
109  /// Print the \LazyValueInfo Analysis.
110  /// We pass in the DTree that is required for identifying which basic blocks
111  /// we can solve/print for, in the LVIPrinter. The DT is optional
112  /// in LVI, so we need to pass it here as an argument.
113  void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
114 
115  /// Disables use of the DominatorTree within LVI.
116  void disableDT();
117 
118  /// Enables use of the DominatorTree within LVI. Does nothing if the class
119  /// instance was initialized without a DT pointer.
120  void enableDT();
121 
122  // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
123  void releaseMemory();
124 
125  /// Handle invalidation events in the new pass manager.
126  bool invalidate(Function &F, const PreservedAnalyses &PA,
128 };
129 
130 /// Analysis to compute lazy value information.
131 class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
132 public:
134  Result run(Function &F, FunctionAnalysisManager &FAM);
135 
136 private:
137  static AnalysisKey Key;
139 };
140 
141 /// Wrapper around LazyValueInfo.
144  void operator=(const LazyValueInfoWrapperPass&) = delete;
145 public:
146  static char ID;
149  }
151  assert(!Info.PImpl && "releaseMemory not called");
152  }
153 
154  LazyValueInfo &getLVI();
155 
156  void getAnalysisUsage(AnalysisUsage &AU) const override;
157  void releaseMemory() override;
158  bool runOnFunction(Function &F) override;
159 private:
161 };
162 
163 } // end namespace llvm
164 
165 #endif
166 
uint64_t CallInst * C
LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_, TargetLibraryInfo *TLI_, DominatorTree *DT_)
Definition: LazyValueInfo.h:43
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:110
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
ConstantRange getConstantRange(Value *V, BasicBlock *BB, Instruction *CxtI=nullptr)
Return the ConstantRange constraint that is known to hold for the specified value at the end of the s...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Wrapper around LazyValueInfo.
void initializeLazyValueInfoWrapperPassPass(PassRegistry &)
A cache of @llvm.assume calls within a function.
F(f)
friend class LazyValueInfoWrapperPass
Definition: LazyValueInfo.h:32
Constant * getConstant(Value *V, BasicBlock *BB, Instruction *CxtI=nullptr)
Determine whether the specified value is known to be a constant at the end of the specified block...
Key
PAL metadata keys.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:144
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
static bool runOnFunction(Function &F, bool PostInlining)
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
Constant * getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB, Instruction *CxtI=nullptr)
Determine whether the specified value is known to be a constant on the specified edge.
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
This is an important base class in LLVM.
Definition: Constant.h:41
bool invalidate(Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &Inv)
Handle invalidation events in the new pass manager.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:389
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Tristate
This is used to return true/false/dunno results.
Definition: LazyValueInfo.h:62
Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C, BasicBlock *FromBB, BasicBlock *ToBB, Instruction *CxtI=nullptr)
Determine whether the specified value comparison with a constant is known to be true or false on the ...
Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C, Instruction *CxtI)
Determine whether the specified value comparison with a constant is known to be true or false at the ...
void enableDT()
Enables use of the DominatorTree within LVI.
Provides information about what library functions are available for the current target.
This class represents a range of values.
Definition: ConstantRange.h:47
void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc)
Inform the analysis cache that we have threaded an edge from PredBB to OldSucc to be from PredBB to N...
LazyValueInfo & operator=(LazyValueInfo &&Arg)
Definition: LazyValueInfo.h:50
void eraseBlock(BasicBlock *BB)
Inform the analysis cache that we have erased a block.
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:648
This pass computes, caches, and vends lazy value constraint information.
Definition: LazyValueInfo.h:31
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:72
LazyValueInfo(LazyValueInfo &&Arg)
Definition: LazyValueInfo.h:46
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
A container for analyses that lazily runs them and caches their results.
void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS)
Print the Analysis.
ConstantRange getConstantRangeOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB, Instruction *CxtI=nullptr)
Return the ConstantRage constraint that is known to hold for the specified value on the specified edg...
This header defines various interfaces for pass management in LLVM.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:70
void disableDT()
Disables use of the DominatorTree within LVI.
Analysis to compute lazy value information.