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

Declarations

include/llvm/CodeGen/CalcSpillWeights.h

   19 class MachineBlockFrequencyInfo;

include/llvm/CodeGen/GlobalISel/RegBankSelect.h

   79 class MachineBlockFrequencyInfo;

include/llvm/CodeGen/LiveIntervals.h

   45 class MachineBlockFrequencyInfo;

include/llvm/CodeGen/LiveRangeEdit.h

   37 class MachineBlockFrequencyInfo;

include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h

   23 class MachineBlockFrequencyInfo;

include/llvm/CodeGen/MachineSizeOpts.h

   22 class MachineBlockFrequencyInfo;

include/llvm/CodeGen/RegAllocPBQP.h

   38 class MachineBlockFrequencyInfo;

lib/CodeGen/BranchFolding.h

   24 class MachineBlockFrequencyInfo;

lib/CodeGen/SpillPlacement.h

   39 class MachineBlockFrequencyInfo;

lib/CodeGen/SplitKit.h

   39 class MachineBlockFrequencyInfo;

References

include/llvm/Analysis/BlockFrequencyInfoImpl.h

 1368   using GTraits = GraphTraits<BlockFrequencyInfoT *>;
 1378   static std::string getGraphName(const BlockFrequencyInfoT *G) {
 1382   std::string getNodeAttributes(NodeRef Node, const BlockFrequencyInfoT *Graph,
 1412   std::string getNodeLabel(NodeRef Node, const BlockFrequencyInfoT *Graph,
 1444                                 const BlockFrequencyInfoT *BFI,

include/llvm/CodeGen/CalcSpillWeights.h

   55     const MachineBlockFrequencyInfo &MBFI;
   62                    const MachineBlockFrequencyInfo &mbfi,
  101                                      const MachineBlockFrequencyInfo &MBFI,

include/llvm/CodeGen/GlobalISel/RegBankSelect.h

  497   MachineBlockFrequencyInfo *MBFI = nullptr;

include/llvm/CodeGen/LazyMachineBlockFrequencyInfo.h

   40   mutable std::unique_ptr<MachineBlockFrequencyInfo> OwnedMBFI;
   53   MachineBlockFrequencyInfo &calculateIfNotAvailable() const;
   61   MachineBlockFrequencyInfo &getBFI() { return calculateIfNotAvailable(); }
   64   const MachineBlockFrequencyInfo &getBFI() const {

include/llvm/CodeGen/LiveIntervals.h

  106                                 const MachineBlockFrequencyInfo *MBFI,
  111                                 const MachineBlockFrequencyInfo *MBFI,

include/llvm/CodeGen/LiveRangeEdit.h

  252                                 const MachineBlockFrequencyInfo &);

include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h

  147                                    MachineBlockFrequencyInfo *MBFI)
  189   MachineBlockFrequencyInfo *MBFI;

include/llvm/CodeGen/MachineSizeOpts.h

   28                            const MachineBlockFrequencyInfo *BFI);
   33                            const MachineBlockFrequencyInfo *MBFI);

include/llvm/CodeGen/RegAllocPBQP.h

  139                 MachineBlockFrequencyInfo &MBFI)
  144   MachineBlockFrequencyInfo &MBFI;

include/llvm/Pass.h

  213   AnalysisType &getAnalysisID(AnalysisID PI) const;

include/llvm/PassAnalysisSupport.h

   66     return addRequiredID(PassClass::ID);
   89     Preserved.push_back(&PassClass::ID);
  201 AnalysisType *Pass::getAnalysisIfAvailable() const {
  204   const void *PI = &AnalysisType::ID;
  220 AnalysisType &Pass::getAnalysis() const {
  222   return getAnalysisID<AnalysisType>(&AnalysisType::ID);
  222   return getAnalysisID<AnalysisType>(&AnalysisType::ID);

include/llvm/PassSupport.h

   76 template <typename PassName> Pass *callDefaultCtor() { return new PassName(); }

lib/CodeGen/BranchFolding.cpp

  103       AU.addRequired<MachineBlockFrequencyInfo>();
  129       getAnalysis<MachineBlockFrequencyInfo>());

lib/CodeGen/BranchFolding.h

  138       MBFIWrapper(const MachineBlockFrequencyInfo &I) : MBFI(I) {}
  150       const MachineBlockFrequencyInfo &MBFI;

lib/CodeGen/GlobalISel/RegBankSelect.cpp

   88     MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
  102     AU.addRequired<MachineBlockFrequencyInfo>();
  883   const MachineBlockFrequencyInfo *MBFI =
  884       P.getAnalysisIfAvailable<MachineBlockFrequencyInfo>();
  891   const MachineBlockFrequencyInfo *MBFI =
  892       P.getAnalysisIfAvailable<MachineBlockFrequencyInfo>();
  912   const MachineBlockFrequencyInfo *MBFI =
  913       P.getAnalysisIfAvailable<MachineBlockFrequencyInfo>();

lib/CodeGen/IfConversion.cpp

  212       AU.addRequired<MachineBlockFrequencyInfo>();
  445   BranchFolder::MBFIWrapper MBFI(getAnalysis<MachineBlockFrequencyInfo>());

lib/CodeGen/InlineSpiller.cpp

   96   const MachineBlockFrequencyInfo &MBFI;
  148         MBFI(pass.getAnalysis<MachineBlockFrequencyInfo>()),
  169   const MachineBlockFrequencyInfo &MBFI;
  204         MBFI(pass.getAnalysis<MachineBlockFrequencyInfo>()),

lib/CodeGen/LazyMachineBlockFrequencyInfo.cpp

   55 MachineBlockFrequencyInfo &
   57   auto *MBFI = getAnalysisIfAvailable<MachineBlockFrequencyInfo>();
   57   auto *MBFI = getAnalysisIfAvailable<MachineBlockFrequencyInfo>();
   87   OwnedMBFI = std::make_unique<MachineBlockFrequencyInfo>();

lib/CodeGen/LiveIntervals.cpp

  854                                     const MachineBlockFrequencyInfo *MBFI,
  860                                     const MachineBlockFrequencyInfo *MBFI,

lib/CodeGen/MachineBlockFrequencyInfo.cpp

   92   static NodeRef getEntryNode(const MachineBlockFrequencyInfo *G) {
  112     BFIDOTGraphTraitsBase<MachineBlockFrequencyInfo,
  125                            const MachineBlockFrequencyInfo *Graph) {
  147                                 const MachineBlockFrequencyInfo *Graph) {
  153                                 const MachineBlockFrequencyInfo *MBFI) {

lib/CodeGen/MachineBlockPlacement.cpp

  536     AU.addRequired<MachineBlockFrequencyInfo>();
 2986       getAnalysis<MachineBlockFrequencyInfo>());
 3102   const MachineBlockFrequencyInfo *MBFI;
 3115     AU.addRequired<MachineBlockFrequencyInfo>();
 3140   MBFI = &getAnalysis<MachineBlockFrequencyInfo>();

lib/CodeGen/MachineCSE.cpp

   70     MachineBlockFrequencyInfo *MBFI;
   88       AU.addRequired<MachineBlockFrequencyInfo>();
   89       AU.addPreserved<MachineBlockFrequencyInfo>();
  890   MBFI = &getAnalysis<MachineBlockFrequencyInfo>();

lib/CodeGen/MachineOptimizationRemarkEmitter.cpp

   72   MachineBlockFrequencyInfo *MBFI;

lib/CodeGen/MachineSink.cpp

   91     const MachineBlockFrequencyInfo *MBFI;
  129         AU.addRequired<MachineBlockFrequencyInfo>();
  312   MBFI = UseBlockFreqInfo ? &getAnalysis<MachineBlockFrequencyInfo>() : nullptr;

lib/CodeGen/MachineSizeOpts.cpp

   31                  const MachineBlockFrequencyInfo *MBFI) {
   40                                     const MachineBlockFrequencyInfo *MBFI) {
   50     const MachineBlockFrequencyInfo &MBFI) {
   66     const MachineBlockFrequencyInfo &MBFI) {
   82                                         const MachineBlockFrequencyInfo &MBFI) {
   89       const MachineBlockFrequencyInfo &MBFI) {
   95                           const MachineBlockFrequencyInfo *MBFI) {
  101                                       const MachineBlockFrequencyInfo *MBFI) {
  110                                  const MachineBlockFrequencyInfo *MBFI) {
  117                                  const MachineBlockFrequencyInfo *MBFI) {

lib/CodeGen/RegAllocBasic.cpp

  183   AU.addRequired<MachineBlockFrequencyInfo>();
  184   AU.addPreserved<MachineBlockFrequencyInfo>();
  316                                 getAnalysis<MachineBlockFrequencyInfo>());

lib/CodeGen/RegAllocGreedy.cpp

  168   MachineBlockFrequencyInfo *MBFI;
  606   AU.addRequired<MachineBlockFrequencyInfo>();
  607   AU.addPreserved<MachineBlockFrequencyInfo>();
 3233   MBFI = &getAnalysis<MachineBlockFrequencyInfo>();

lib/CodeGen/RegAllocPBQP.cpp

  440     MachineBlockFrequencyInfo &MBFI = G.getMetadata().MBFI;
  544   au.addRequired<MachineBlockFrequencyInfo>();
  545   au.addPreserved<MachineBlockFrequencyInfo>();
  791   MachineBlockFrequencyInfo &MBFI =
  792     getAnalysis<MachineBlockFrequencyInfo>();

lib/CodeGen/ShrinkWrap.cpp

  127   MachineBlockFrequencyInfo *MBFI;
  193     MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
  225     AU.addRequired<MachineBlockFrequencyInfo>();

lib/CodeGen/SpillPlacement.cpp

   64   AU.addRequired<MachineBlockFrequencyInfo>();
  208   MBFI = &getAnalysis<MachineBlockFrequencyInfo>();

lib/CodeGen/SpillPlacement.h

   48   const MachineBlockFrequencyInfo *MBFI;

lib/CodeGen/SplitKit.cpp

  368                          MachineBlockFrequencyInfo &mbfi)

lib/CodeGen/SplitKit.h

  266   const MachineBlockFrequencyInfo &MBFI;
  447               MachineBlockFrequencyInfo &mbfi);

lib/CodeGen/StackSlotColoring.cpp

   64     const MachineBlockFrequencyInfo *MBFI;
  108       AU.addRequired<MachineBlockFrequencyInfo>();
  109       AU.addPreserved<MachineBlockFrequencyInfo>();
  494   MBFI = &getAnalysis<MachineBlockFrequencyInfo>();

lib/Target/PowerPC/PPCMIPeephole.cpp

   94   MachineBlockFrequencyInfo *MBFI;
  116     AU.addRequired<MachineBlockFrequencyInfo>();
  119     AU.addPreserved<MachineBlockFrequencyInfo>();
  138   MBFI = &getAnalysis<MachineBlockFrequencyInfo>();

lib/Target/WebAssembly/WebAssemblyArgumentMove.cpp

   52     AU.addPreserved<MachineBlockFrequencyInfo>();

lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp

   51     AU.addPreserved<MachineBlockFrequencyInfo>();

lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp

   57     AU.addRequired<MachineBlockFrequencyInfo>();
   58     AU.addPreserved<MachineBlockFrequencyInfo>();

lib/Target/WebAssembly/WebAssemblyOptimizeLiveIntervals.cpp

   43     AU.addPreserved<MachineBlockFrequencyInfo>();

lib/Target/WebAssembly/WebAssemblyRegColoring.cpp

   44     AU.addRequired<MachineBlockFrequencyInfo>();
   45     AU.addPreserved<MachineBlockFrequencyInfo>();
   66                            const MachineBlockFrequencyInfo *MBFI,
   90   const MachineBlockFrequencyInfo *MBFI =
   91       &getAnalysis<MachineBlockFrequencyInfo>();

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

   54     AU.addPreserved<MachineBlockFrequencyInfo>();

lib/Target/WebAssembly/WebAssemblySetP2AlignOperands.cpp

   39     AU.addPreserved<MachineBlockFrequencyInfo>();

unittests/Target/X86/MachineSizeOptsTest.cpp

   50     std::unique_ptr<MachineBlockFrequencyInfo> MBFI;
   55       MBFI.reset(new MachineBlockFrequencyInfo(MF, *MBPI, *MLI));
   57     MachineBlockFrequencyInfo *get() { return MBFI.get(); }
  104   MachineBlockFrequencyInfo *MBFI_F = BFID_F.get();
  105   MachineBlockFrequencyInfo *MBFI_G = BFID_G.get();
  106   MachineBlockFrequencyInfo *MBFI_H = BFID_H.get();

usr/include/c++/7.4.0/bits/move.h

   72     constexpr _Tp&&
   83     constexpr _Tp&&

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)...)); }

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;
 1633     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>