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