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/Analysis/BlockFrequencyInfo.h
   26 class BranchProbabilityInfo;
include/llvm/Analysis/BlockFrequencyInfoImpl.h
   51 class BranchProbabilityInfo;
include/llvm/Analysis/LazyBlockFrequencyInfo.h
   25 class BranchProbabilityInfo;
include/llvm/CodeGen/FunctionLoweringInfo.h
   38 class BranchProbabilityInfo;
include/llvm/Transforms/Utils/BasicBlockUtils.h
   29 class BranchProbabilityInfo;
include/llvm/Transforms/Utils/CodeExtractor.h
   29 class BranchProbabilityInfo;

References

include/llvm/Analysis/BlockFrequencyInfo.h
   44   BlockFrequencyInfo(const Function &F, const BranchProbabilityInfo &BPI,
   57   const BranchProbabilityInfo *getBPI() const;
   92   void calculate(const Function &F, const BranchProbabilityInfo &BPI,
include/llvm/Analysis/BlockFrequencyInfoImpl.h
  548   using BranchProbabilityInfoT = BranchProbabilityInfo;
 1445                                 const BranchProbabilityInfoT *BPI,
include/llvm/Analysis/BranchProbabilityInfo.h
   61   BranchProbabilityInfo(BranchProbabilityInfo &&Arg)
   66   BranchProbabilityInfo(const BranchProbabilityInfo &) = delete;
   67   BranchProbabilityInfo &operator=(const BranchProbabilityInfo &) = delete;
   67   BranchProbabilityInfo &operator=(const BranchProbabilityInfo &) = delete;
   69   BranchProbabilityInfo &operator=(BranchProbabilityInfo &&RHS) {
   69   BranchProbabilityInfo &operator=(BranchProbabilityInfo &&RHS) {
  152     BranchProbabilityInfo *BPI;
  161     BasicBlockCallbackVH(const Value *V, BranchProbabilityInfo *BPI = nullptr)
  212   using Result = BranchProbabilityInfo;
  215   BranchProbabilityInfo run(Function &F, FunctionAnalysisManager &AM);
  231   BranchProbabilityInfo BPI;
  241   BranchProbabilityInfo &getBPI() { return BPI; }
  242   const BranchProbabilityInfo &getBPI() const { return BPI; }
include/llvm/Analysis/LazyBranchProbabilityInfo.h
   63     BranchProbabilityInfo &getCalculated() {
   72     const BranchProbabilityInfo &getCalculated() const {
   77     BranchProbabilityInfo BPI;
   92   BranchProbabilityInfo &getBPI() { return LBPI->getCalculated(); }
   95   const BranchProbabilityInfo &getBPI() const { return LBPI->getCalculated(); }
  118   static BranchProbabilityInfo &getBPI(LazyBranchProbabilityInfoPass *P) {
include/llvm/CodeGen/FunctionLoweringInfo.h
   59   BranchProbabilityInfo *BPI;
include/llvm/ExecutionEngine/Orc/SpeculateAnalyses.h
   70                             const BranchProbabilityInfo *,
   74                            const BranchProbabilityInfo *,
include/llvm/IR/PassManagerInternal.h
  137   template <typename T> struct Checker : CheckerBase, T {};
  139   static decltype(NonceFunction(&Checker<T>::invalidate)) check(rank<1>);
  147   enum { Value = sizeof(check<ResultT>(rank<2>())) == sizeof(EnabledType) };
  169   explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
  198   ResultT Result;
include/llvm/Transforms/Scalar/JumpThreading.h
   83   std::unique_ptr<BranchProbabilityInfo> BPI;
  101                std::unique_ptr<BranchProbabilityInfo> BPI_);
include/llvm/Transforms/Utils/BasicBlockUtils.h
  358                                   BranchProbabilityInfo *BPI = nullptr,
include/llvm/Transforms/Utils/CodeExtractor.h
   92     BranchProbabilityInfo *BPI;
  121                   BranchProbabilityInfo *BPI = nullptr,
  132                   BranchProbabilityInfo *BPI = nullptr,
  224         BranchProbabilityInfo *BPI);
lib/Analysis/BlockFrequencyInfo.cpp
  123     BFIDOTGraphTraitsBase<BlockFrequencyInfo, BranchProbabilityInfo>;
  154                                        const BranchProbabilityInfo &BPI,
  184                                    const BranchProbabilityInfo &BPI,
  263 const BranchProbabilityInfo *BlockFrequencyInfo::getBPI() const {
  319   BranchProbabilityInfo &BPI =
lib/Analysis/BranchProbabilityInfo.cpp
  434                      const BranchProbabilityInfo::SccInfo &SccI) {
  443                         BranchProbabilityInfo::SccInfo &SccI) {
  452   BranchProbabilityInfo::SccHeaderMap::iterator HeaderMapIt;
 1043 BranchProbabilityInfo
 1045   BranchProbabilityInfo BPI;
lib/Analysis/ModuleSummaryAnalysis.cpp
  743       BranchProbabilityInfo BPI{F, LI};
lib/Analysis/OptimizationRemarkEmitter.cpp
   38   BranchProbabilityInfo BPI;
lib/CodeGen/CodeGenPrepare.cpp
  253     std::unique_ptr<BranchProbabilityInfo> BPI;
  430   BPI.reset(new BranchProbabilityInfo(F, *LI));
lib/CodeGen/GlobalISel/IRTranslator.cpp
  439   BranchProbabilityInfo *BPI = FuncInfo.BPI;
lib/CodeGen/SafeStack.cpp
  468   auto SuccessProb = BranchProbabilityInfo::getBranchProbStackProtector(true);
  469   auto FailureProb = BranchProbabilityInfo::getBranchProbStackProtector(false);
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
 1731     BranchProbabilityInfo *BPI = FuncInfo.BPI;
 1742   BranchProbabilityInfo *BPI = FuncInfo.BPI;
 1988   BranchProbabilityInfo *BPI = FuncInfo.BPI;
 2806   BranchProbabilityInfo *BPI = FuncInfo.BPI;
10018       SuccMBB, BranchProbabilityInfo::getBranchProbStackProtector(IsLikely));
10053   BranchProbabilityInfo *BPI = FuncInfo.BPI;
10496   BranchProbabilityInfo *BPI = FuncInfo.BPI;
lib/CodeGen/StackProtector.cpp
  506           BranchProbabilityInfo::getBranchProbStackProtector(true);
  508           BranchProbabilityInfo::getBranchProbStackProtector(false);
lib/ExecutionEngine/Orc/SpeculateAnalyses.cpp
  261   BranchProbabilityInfo *BPI =
lib/Transforms/IPO/PartialInlining.cpp
  398   BranchProbabilityInfo BPI(*F, LI);
  938         BranchProbabilityInfo BPI(*Caller, LI);
 1122   BranchProbabilityInfo BPI(*ClonedFunc, LI);
 1197   BranchProbabilityInfo BPI(*ClonedFunc, LI);
lib/Transforms/Instrumentation/CFGMST.h
  271   BranchProbabilityInfo *BPI;
  275   CFGMST(Function &Func, BranchProbabilityInfo *BPI_ = nullptr,
lib/Transforms/Instrumentation/InstrProfiling.cpp
  450     std::unique_ptr<BranchProbabilityInfo> BPI;
  451     BPI.reset(new BranchProbabilityInfo(*F, LI, &GetTLI(*F)));
lib/Transforms/Instrumentation/PGOInstrumentation.cpp
  569       bool CreateGlobalVar = false, BranchProbabilityInfo *BPI = nullptr,
  804     Function &F, Module *M, BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFI,
  957              BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFIin,
 1462     Module &M, function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
 1474     auto *BPI = LookupBPI(F);
 1520     function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
 1567     auto *BPI = LookupBPI(F);
 1595       std::unique_ptr<BranchProbabilityInfo> NewBPI =
 1596           std::make_unique<BranchProbabilityInfo>(F, LI);
lib/Transforms/Scalar/GuardWidening.cpp
  129   BranchProbabilityInfo *BPI;
  290                              LoopInfo &LI, BranchProbabilityInfo *BPI,
  808   BranchProbabilityInfo *BPI = nullptr;
  827   BranchProbabilityInfo *BPI = nullptr;
  859     BranchProbabilityInfo *BPI = nullptr;
  898     BranchProbabilityInfo *BPI = nullptr;
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
  225                                BranchProbabilityInfo *BPI,
  231   BranchProbabilityInfo *BPI;
  237                                  BranchProbabilityInfo *BPI, DominatorTree &DT,
  392     BranchInst *BI, Loop *L, ScalarEvolution &SE, BranchProbabilityInfo *BPI,
  491                                                     BranchProbabilityInfo *BPI,
  737                                   BranchProbabilityInfo *BPI, Loop &L,
 1755   auto *BPI = FAM.getCachedResult<BranchProbabilityAnalysis>(*F);
 1773   BranchProbabilityInfo &BPI =
lib/Transforms/Scalar/JumpThreading.cpp
  307   std::unique_ptr<BranchProbabilityInfo> BPI;
  311     BPI.reset(new BranchProbabilityInfo(F, LI, TLI));
  335   std::unique_ptr<BranchProbabilityInfo> BPI;
  338     BPI.reset(new BranchProbabilityInfo(F, LI, &TLI));
  358                                 std::unique_ptr<BranchProbabilityInfo> BPI_) {
lib/Transforms/Scalar/LoopPredication.cpp
  252   BranchProbabilityInfo *BPI;
  305                   BranchProbabilityInfo *BPI)
  326     BranchProbabilityInfo &BPI =
  354   auto *BPI = FAM.getCachedResult<BranchProbabilityAnalysis>(*F);
lib/Transforms/Utils/BreakCriticalEdges.cpp
  357                                         BranchProbabilityInfo *BPI,
lib/Transforms/Utils/CodeExtractor.cpp
  246                              BranchProbabilityInfo *BPI, AssumptionCache *AC,
  256                              BranchProbabilityInfo *BPI, AssumptionCache *AC,
 1343     BranchProbabilityInfo *BPI) {
unittests/Analysis/BlockFrequencyInfoTest.cpp
   29   std::unique_ptr<BranchProbabilityInfo> BPI;
   37     BPI.reset(new BranchProbabilityInfo(F, *LI));
unittests/Analysis/BranchProbabilityInfoTest.cpp
   28   std::unique_ptr<BranchProbabilityInfo> BPI;
   33   BranchProbabilityInfo &buildBPI(Function &F) {
   36     BPI.reset(new BranchProbabilityInfo(F, *LI));
   77   BranchProbabilityInfo &BPI = buildBPI(*F);
unittests/Analysis/ProfileSummaryInfoTest.cpp
   33   std::unique_ptr<BranchProbabilityInfo> BPI;
   43     BPI.reset(new BranchProbabilityInfo(F, *LI));
unittests/Transforms/Utils/SizeOptsTest.cpp
   36     std::unique_ptr<BranchProbabilityInfo> BPI;
   41       BPI.reset(new BranchProbabilityInfo(F, *LI));
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
   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  824     make_unique(_Args&&... __args)
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
  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; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 2253     inline typename add_rvalue_reference<_Tp>::type