LCOV - code coverage report
Current view: top level - include/llvm/Analysis - LazyValueInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 9 9 100.0 %
Date: 2017-09-14 15:23:50 Functions: 2 3 66.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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        4012 :   LazyValueInfo() {}
      44             :   LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_, TargetLibraryInfo *TLI_,
      45             :                 DominatorTree *DT_)
      46         206 :       : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {}
      47             :   LazyValueInfo(LazyValueInfo &&Arg)
      48         412 :       : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) {
      49         412 :     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       12036 :   LazyValueInfoWrapperPass() : FunctionPass(ID) {
     142        4012 :     initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
     143        4012 :   }
     144        8024 :   ~LazyValueInfoWrapperPass() override {
     145             :     assert(!Info.PImpl && "releaseMemory not called");
     146        4012 :   }
     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             : 

Generated by: LCOV version 1.13