Home | History | Annotate | Download | only in Analysis 
      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   /// 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   // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
    117   void releaseMemory();
    118 
    119   /// Handle invalidation events in the new pass manager.
    120   bool invalidate(Function &F, const PreservedAnalyses &PA,
    121                   FunctionAnalysisManager::Invalidator &Inv);
    122 };
    123 
    124 /// \brief Analysis to compute lazy value information.
    125 class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
    126 public:
    127   typedef LazyValueInfo Result;
    128   Result run(Function &F, FunctionAnalysisManager &FAM);
    129 
    130 private:
    131   static AnalysisKey Key;
    132   friend struct AnalysisInfoMixin<LazyValueAnalysis>;
    133 };
    134 
    135 /// Wrapper around LazyValueInfo.
    136 class LazyValueInfoWrapperPass : public FunctionPass {
    137   LazyValueInfoWrapperPass(const LazyValueInfoWrapperPass&) = delete;
    138   void operator=(const LazyValueInfoWrapperPass&) = delete;
    139 public:
    140   static char ID;
    141   LazyValueInfoWrapperPass() : FunctionPass(ID) {
    142     initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
    143   }
    144   ~LazyValueInfoWrapperPass() override {
    145     assert(!Info.PImpl && "releaseMemory not called");
    146   }
    147 
    148   LazyValueInfo &getLVI();
    149 
    150   void getAnalysisUsage(AnalysisUsage &AU) const override;
    151   void releaseMemory() override;
    152   bool runOnFunction(Function &F) override;
    153 private:
    154   LazyValueInfo Info;
    155 };
    156 
    157 }  // end namespace llvm
    158 
    159 #endif
    160 
    161