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 LazyValueInfo() {} 44 LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_, TargetLibraryInfo *TLI_, 45 DominatorTree *DT_) 46 : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {} 47 LazyValueInfo(LazyValueInfo &&Arg) 48 : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) { 49 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 /// Inform the analysis cache that we have threaded an edge from 97 /// PredBB to OldSucc to be from PredBB to NewSucc instead. 98 void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc); 99 100 /// Inform the analysis cache that we have erased a block. 101 void eraseBlock(BasicBlock *BB); 102 103 /// Print the \LazyValueInfo Analysis. 104 /// We pass in the DTree that is required for identifying which basic blocks 105 /// we can solve/print for, in the LVIPrinter. The DT is optional 106 /// in LVI, so we need to pass it here as an argument. 107 void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS); 108 109 // For old PM pass. Delete once LazyValueInfoWrapperPass is gone. 110 void releaseMemory(); 111 112 /// Handle invalidation events in the new pass manager. 113 bool invalidate(Function &F, const PreservedAnalyses &PA, 114 FunctionAnalysisManager::Invalidator &Inv); 115 }; 116 117 /// \brief Analysis to compute lazy value information. 118 class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> { 119 public: 120 typedef LazyValueInfo Result; 121 Result run(Function &F, FunctionAnalysisManager &FAM); 122 123 private: 124 static AnalysisKey Key; 125 friend struct AnalysisInfoMixin<LazyValueAnalysis>; 126 }; 127 128 /// Wrapper around LazyValueInfo. 129 class LazyValueInfoWrapperPass : public FunctionPass { 130 LazyValueInfoWrapperPass(const LazyValueInfoWrapperPass&) = delete; 131 void operator=(const LazyValueInfoWrapperPass&) = delete; 132 public: 133 static char ID; 134 LazyValueInfoWrapperPass() : FunctionPass(ID) { 135 initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry()); 136 } 137 ~LazyValueInfoWrapperPass() override { 138 assert(!Info.PImpl && "releaseMemory not called"); 139 } 140 141 LazyValueInfo &getLVI(); 142 143 void getAnalysisUsage(AnalysisUsage &AU) const override; 144 void releaseMemory() override; 145 bool runOnFunction(Function &F) override; 146 private: 147 LazyValueInfo Info; 148 }; 149 150 } // end namespace llvm 151 152 #endif 153 154
