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: 2018-05-20 00:06:23 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        2864 :   LazyValueInfo() {}
      44             :   LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_, TargetLibraryInfo *TLI_,
      45             :                 DominatorTree *DT_)
      46         239 :       : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {}
      47             :   LazyValueInfo(LazyValueInfo &&Arg)
      48         478 :       : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) {
      49         478 :     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             :   /// Disables use of the DominatorTree within LVI.
     117             :   void disableDT();
     118             : 
     119             :   /// Enables use of the DominatorTree within LVI. Does nothing if the class
     120             :   /// instance was initialized without a DT pointer.
     121             :   void enableDT();
     122             : 
     123             :   // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
     124             :   void releaseMemory();
     125             : 
     126             :   /// Handle invalidation events in the new pass manager.
     127             :   bool invalidate(Function &F, const PreservedAnalyses &PA,
     128             :                   FunctionAnalysisManager::Invalidator &Inv);
     129             : };
     130             : 
     131             : /// Analysis to compute lazy value information.
     132             : class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
     133             : public:
     134             :   typedef LazyValueInfo Result;
     135             :   Result run(Function &F, FunctionAnalysisManager &FAM);
     136             : 
     137             : private:
     138             :   static AnalysisKey Key;
     139             :   friend struct AnalysisInfoMixin<LazyValueAnalysis>;
     140             : };
     141             : 
     142             : /// Wrapper around LazyValueInfo.
     143             : class LazyValueInfoWrapperPass : public FunctionPass {
     144             :   LazyValueInfoWrapperPass(const LazyValueInfoWrapperPass&) = delete;
     145             :   void operator=(const LazyValueInfoWrapperPass&) = delete;
     146             : public:
     147             :   static char ID;
     148        5728 :   LazyValueInfoWrapperPass() : FunctionPass(ID) {
     149        2864 :     initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
     150        2864 :   }
     151        5728 :   ~LazyValueInfoWrapperPass() override {
     152             :     assert(!Info.PImpl && "releaseMemory not called");
     153        2864 :   }
     154             : 
     155             :   LazyValueInfo &getLVI();
     156             : 
     157             :   void getAnalysisUsage(AnalysisUsage &AU) const override;
     158             :   void releaseMemory() override;
     159             :   bool runOnFunction(Function &F) override;
     160             : private:
     161             :   LazyValueInfo Info;
     162             : };
     163             : 
     164             : }  // end namespace llvm
     165             : 
     166             : #endif
     167             : 

Generated by: LCOV version 1.13