1 //===- LazyValueInfo.h - Value constraint analysis --------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This file defines the interface for lazy computation of value constraint
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_ANALYSIS_LAZYVALUEINFO_H
15 #define LLVM_ANALYSIS_LAZYVALUEINFO_H
17 #include "llvm/IR/PassManager.h"
18 #include "llvm/Pass.h"
21 class AssumptionCache;
27 class TargetLibraryInfo;
30 /// This pass computes, caches, and vends lazy value constraint information.
32 friend class LazyValueInfoWrapperPass;
33 AssumptionCache *AC = nullptr;
34 const DataLayout *DL = nullptr;
35 class TargetLibraryInfo *TLI = nullptr;
36 void *PImpl = nullptr;
37 LazyValueInfo(const LazyValueInfo&) = delete;
38 void operator=(const LazyValueInfo&) = delete;
42 LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_,
43 TargetLibraryInfo *TLI_)
44 : AC(AC_), DL(DL_), TLI(TLI_) {}
45 LazyValueInfo(LazyValueInfo &&Arg)
46 : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), PImpl(Arg.PImpl) {
49 LazyValueInfo &operator=(LazyValueInfo &&Arg) {
59 /// This is used to return true/false/dunno results.
61 Unknown = -1, False = 0, True = 1
64 // Public query interface.
66 /// Determine whether the specified value comparison with a constant is known
67 /// to be true or false on the specified CFG edge.
68 /// Pred is a CmpInst predicate.
69 Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
70 BasicBlock *FromBB, BasicBlock *ToBB,
71 Instruction *CxtI = nullptr);
73 /// Determine whether the specified value comparison with a constant is known
74 /// to be true or false at the specified instruction
75 /// (from an assume intrinsic). Pred is a CmpInst predicate.
76 Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
79 /// Determine whether the specified value is known to be a
80 /// constant at the end of the specified block. Return null if not.
81 Constant *getConstant(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
83 /// Return the ConstantRange constraint that is known to hold for the
84 /// specified value at the end of the specified block. This may only be called
85 /// on integer-typed Values.
86 ConstantRange getConstantRange(Value *V, BasicBlock *BB,
87 Instruction *CxtI = nullptr,
88 bool UndefAllowed = true);
90 /// Determine whether the specified value is known to be a
91 /// constant on the specified edge. Return null if not.
92 Constant *getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
93 Instruction *CxtI = nullptr);
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.
98 ConstantRange getConstantRangeOnEdge(Value *V, BasicBlock *FromBB,
100 Instruction *CxtI = nullptr);
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);
106 /// Inform the analysis cache that we have erased a block.
107 void eraseBlock(BasicBlock *BB);
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.
112 void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
114 // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
115 void releaseMemory();
117 /// Handle invalidation events in the new pass manager.
118 bool invalidate(Function &F, const PreservedAnalyses &PA,
119 FunctionAnalysisManager::Invalidator &Inv);
122 /// Analysis to compute lazy value information.
123 class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
125 typedef LazyValueInfo Result;
126 Result run(Function &F, FunctionAnalysisManager &FAM);
129 static AnalysisKey Key;
130 friend struct AnalysisInfoMixin<LazyValueAnalysis>;
133 /// Wrapper around LazyValueInfo.
134 class LazyValueInfoWrapperPass : public FunctionPass {
135 LazyValueInfoWrapperPass(const LazyValueInfoWrapperPass&) = delete;
136 void operator=(const LazyValueInfoWrapperPass&) = delete;
139 LazyValueInfoWrapperPass();
140 ~LazyValueInfoWrapperPass() override {
141 assert(!Info.PImpl && "releaseMemory not called");
144 LazyValueInfo &getLVI();
146 void getAnalysisUsage(AnalysisUsage &AU) const override;
147 void releaseMemory() override;
148 bool runOnFunction(Function &F) override;
153 } // end namespace llvm