reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

include/llvm/IR/PassManagerInternal.h
  137   template <typename T> struct Checker : CheckerBase, T {};

Declarations

include/llvm/Transforms/Scalar/JumpThreading.h
   41 class LazyValueInfo;
include/llvm/Transforms/Utils/Local.h
   50 class LazyValueInfo;

References

include/llvm/Analysis/LazyValueInfo.h
   38   LazyValueInfo(const LazyValueInfo&) = delete;
   39   void operator=(const LazyValueInfo&) = delete;
   46   LazyValueInfo(LazyValueInfo &&Arg)
   50   LazyValueInfo &operator=(LazyValueInfo &&Arg) {
   50   LazyValueInfo &operator=(LazyValueInfo &&Arg) {
  133   typedef LazyValueInfo Result;
  154   LazyValueInfo &getLVI();
  160   LazyValueInfo Info;
include/llvm/IR/PassManagerInternal.h
  137   template <typename T> struct Checker : CheckerBase, T {};
  147   enum { Value = sizeof(check<ResultT>(rank<2>())) == sizeof(EnabledType) };
  208   explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
  231   ResultT Result;
include/llvm/Transforms/Scalar/JumpThreading.h
   79   LazyValueInfo *LVI;
   98   bool runImpl(Function &F, TargetLibraryInfo *TLI_, LazyValueInfo *LVI_,
lib/Analysis/LazyValueInfo.cpp
 1645 LazyValueInfo &LazyValueInfoWrapperPass::getLVI() { return Info; }
 1671 LazyValueInfo LazyValueAnalysis::run(Function &F,
 1771 static LazyValueInfo::Tristate
 1779       return ResCI->isZero() ? LazyValueInfo::False : LazyValueInfo::True;
 1779       return ResCI->isZero() ? LazyValueInfo::False : LazyValueInfo::True;
 1780     return LazyValueInfo::Unknown;
 1785     if (!CI) return LazyValueInfo::Unknown;
 1790         return LazyValueInfo::False;
 1793         return LazyValueInfo::True;
 1796         return LazyValueInfo::True;
 1799         return LazyValueInfo::False;
 1805         return LazyValueInfo::True;
 1807         return LazyValueInfo::False;
 1809     return LazyValueInfo::Unknown;
 1821         return LazyValueInfo::False;
 1828         return LazyValueInfo::True;
 1830     return LazyValueInfo::Unknown;
 1833   return LazyValueInfo::Unknown;
 1838 LazyValueInfo::Tristate
 1849 LazyValueInfo::Tristate
 1860       return LazyValueInfo::False;
 1862       return LazyValueInfo::True;
 2054     auto &LVI = getAnalysis<LazyValueInfoWrapperPass>().getLVI();
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp
  125 static bool processSelect(SelectInst *S, LazyValueInfo *LVI) {
  159 static bool simplifyCommonValuePhi(PHINode *P, LazyValueInfo *LVI,
  211 static bool processPHI(PHINode *P, LazyValueInfo *LVI, DominatorTree *DT,
  254             LazyValueInfo::False)
  281 static bool processMemAccess(Instruction *I, LazyValueInfo *LVI) {
  302 static bool processCmp(CmpInst *Cmp, LazyValueInfo *LVI) {
  317   LazyValueInfo::Tristate Result =
  319   if (Result == LazyValueInfo::Unknown)
  336 static bool processSwitch(SwitchInst *I, LazyValueInfo *LVI,
  366       LazyValueInfo::Tristate State = LazyValueInfo::Unknown;
  366       LazyValueInfo::Tristate State = LazyValueInfo::Unknown;
  369         LazyValueInfo::Tristate Value = LVI->getPredicateOnEdge(CmpInst::ICMP_EQ,
  373         if (Value == LazyValueInfo::Unknown) {
  374           State = LazyValueInfo::Unknown;
  388           State = LazyValueInfo::Unknown;
  393       if (State == LazyValueInfo::False) {
  410       if (State == LazyValueInfo::True) {
  434 static bool willNotOverflow(BinaryOpIntrinsic *BO, LazyValueInfo *LVI) {
  491 static bool processBinOp(BinaryOperator *BinOp, LazyValueInfo *LVI);
  494 static void processOverflowIntrinsic(WithOverflowInst *WO, LazyValueInfo *LVI) {
  518 static void processSaturatingInst(SaturatingInst *SI, LazyValueInfo *LVI) {
  537 static bool processCallSite(CallSite CS, LazyValueInfo *LVI) {
  588                             CS.getInstruction()) == LazyValueInfo::False)
  607 static bool hasPositiveOperands(BinaryOperator *SDI, LazyValueInfo *LVI) {
  611     if (Result != LazyValueInfo::True)
  619 static bool processUDivOrURem(BinaryOperator *Instr, LazyValueInfo *LVI) {
  659 static bool processSRem(BinaryOperator *SDI, LazyValueInfo *LVI) {
  681 static bool processSDiv(BinaryOperator *SDI, LazyValueInfo *LVI) {
  699 static bool processAShr(BinaryOperator *SDI, LazyValueInfo *LVI) {
  705       LazyValueInfo::True)
  719 static bool processSExt(SExtInst *SDI, LazyValueInfo *LVI) {
  727       LazyValueInfo::True)
  740 static bool processBinOp(BinaryOperator *BinOp, LazyValueInfo *LVI) {
  783 static bool processAnd(BinaryOperator *BinOp, LazyValueInfo *LVI) {
  806 static Constant *getConstantAt(Value *V, Instruction *At, LazyValueInfo *LVI) {
  819   LazyValueInfo::Tristate Result =
  821   if (Result == LazyValueInfo::Unknown)
  824   return (Result == LazyValueInfo::True) ?
  829 static bool runImpl(Function &F, LazyValueInfo *LVI, DominatorTree *DT,
  919   LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
  927   LazyValueInfo *LVI = &AM.getResult<LazyValueAnalysis>(F);
lib/Transforms/Scalar/JumpThreading.cpp
  330   auto &LVI = AM.getResult<LazyValueAnalysis>(F);
  355                                 LazyValueInfo *LVI_, AliasAnalysis *AA_,
  806           LazyValueInfo::Tristate
  810           if (ResT == LazyValueInfo::Unknown)
  836           LazyValueInfo::Tristate Res =
  839           if (Res == LazyValueInfo::Unknown)
 1154       LazyValueInfo::Tristate Ret =
 1157       if (Ret != LazyValueInfo::Unknown) {
 1158         unsigned ToRemove = Ret == LazyValueInfo::True ? 1 : 0;
 1159         unsigned ToKeep = Ret == LazyValueInfo::True ? 0 : 1;
 1176           auto *CI = Ret == LazyValueInfo::True ?
 2526     LazyValueInfo::Tristate LHSFolds =
 2529     LazyValueInfo::Tristate RHSFolds =
 2532     if ((LHSFolds != LazyValueInfo::Unknown ||
 2533          RHSFolds != LazyValueInfo::Unknown) &&
lib/Transforms/Utils/LowerSwitch.cpp
  103                            AssumptionCache *AC, LazyValueInfo *LVI);
  147   LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
  442                                     AssumptionCache *AC, LazyValueInfo *LVI) {
usr/include/c++/7.4.0/bits/move.h
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
usr/include/c++/7.4.0/bits/unique_ptr.h
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 2253     inline typename add_rvalue_reference<_Tp>::type