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

Declarations

include/llvm/Analysis/BlockFrequencyInfoImpl.h

   59 class MachineLoopInfo;

include/llvm/CodeGen/AsmPrinter.h

   56 class MachineLoopInfo;

include/llvm/CodeGen/CalcSpillWeights.h

   21 class MachineLoopInfo;

include/llvm/CodeGen/DFAPacketizer.h

   44 class MachineLoopInfo;

include/llvm/CodeGen/LiveRangeEdit.h

   39 class MachineLoopInfo;

include/llvm/CodeGen/MachineBlockFrequencyInfo.h

   28 class MachineLoopInfo;

include/llvm/CodeGen/MachineScheduler.h

  109 class MachineLoopInfo;

include/llvm/CodeGen/MachineTraceMetrics.h

   64 class MachineLoopInfo;

include/llvm/CodeGen/ScheduleDAGInstrs.h

   42   class MachineLoopInfo;

lib/CodeGen/BranchFolding.h

   27 class MachineLoopInfo;

lib/CodeGen/SpillPlacement.h

   41 class MachineLoopInfo;

lib/CodeGen/SplitKit.h

   41 class MachineLoopInfo;

lib/Target/Hexagon/HexagonVLIWPacketizer.h

   24 class MachineLoopInfo;

References

include/llvm/Analysis/BlockFrequencyInfoImpl.h

  557   using LoopInfoT = MachineLoopInfo;

include/llvm/Analysis/CFG.h

  145 bool containsIrreducibleCFG(RPOTraversalT &RPOTraversal, const LoopInfoT &LI) {

include/llvm/CodeGen/AsmPrinter.h

  106   MachineLoopInfo *MLI = nullptr;
  177   std::unique_ptr<MachineLoopInfo> OwnedMLI;

include/llvm/CodeGen/CalcSpillWeights.h

   54     const MachineLoopInfo &Loops;
   61                    VirtRegMap *vrm, const MachineLoopInfo &loops,
  100                                      const MachineLoopInfo &MLI,

include/llvm/CodeGen/DFAPacketizer.h

  160   VLIWPacketizerList(MachineFunction &MF, MachineLoopInfo &MLI,

include/llvm/CodeGen/LazyMachineBlockFrequencyInfo.h

   43   mutable std::unique_ptr<MachineLoopInfo> OwnedMLI;

include/llvm/CodeGen/LiveRangeEdit.h

  251   void calculateRegClassAndHint(MachineFunction &, const MachineLoopInfo &,

include/llvm/CodeGen/MachineBlockFrequencyInfo.h

   43                                      MachineLoopInfo &MLI);
   53                  const MachineLoopInfo &MLI);

include/llvm/CodeGen/MachineLoopInfo.h

   99   MachineLoopInfo(const MachineLoopInfo &) = delete;
  100   MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
  100   MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
  180   using ChildIteratorType = MachineLoopInfo::iterator;
  189   using ChildIteratorType = MachineLoopInfo::iterator;

include/llvm/CodeGen/MachinePipeliner.h

   62   const MachineLoopInfo *MLI = nullptr;
   95     AU.addRequired<MachineLoopInfo>();

include/llvm/CodeGen/MachineRegionInfo.h

   42   using LoopInfoT = MachineLoopInfo;

include/llvm/CodeGen/MachineScheduler.h

  121   const MachineLoopInfo *MLI = nullptr;

include/llvm/CodeGen/MachineTraceMetrics.h

   92   const MachineLoopInfo *Loops = nullptr;

include/llvm/CodeGen/ScheduleDAGInstrs.h

  121     const MachineLoopInfo *MLI;
  256                                const MachineLoopInfo *mli,

include/llvm/Pass.h

  213   AnalysisType &getAnalysisID(AnalysisID PI) const;

include/llvm/PassAnalysisSupport.h

   66     return addRequiredID(PassClass::ID);
   72     return addRequiredTransitiveID(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/AsmPrinter/AsmPrinter.cpp

 1041     MLI = getAnalysisIfAvailable<MachineLoopInfo>();
 1043       OwnedMLI = std::make_unique<MachineLoopInfo>();
 2868                                        const MachineLoopInfo *LI,

lib/CodeGen/BranchFolding.cpp

  181                                     MachineLoopInfo *mli, bool AfterPlacement) {

lib/CodeGen/BranchFolding.h

   51                           MachineLoopInfo *mli = nullptr,
  130     MachineLoopInfo *MLI;

lib/CodeGen/CalcSpillWeights.cpp

   34                            const MachineLoopInfo &MLI,

lib/CodeGen/EarlyIfConversion.cpp

  706   MachineLoopInfo *Loops;
  740   AU.addRequired<MachineLoopInfo>();
  741   AU.addPreserved<MachineLoopInfo>();
  767 void updateLoops(MachineLoopInfo *Loops,
  914   Loops = getAnalysisIfAvailable<MachineLoopInfo>();
  943   MachineLoopInfo *Loops;
  974   AU.addRequired<MachineLoopInfo>();
  975   AU.addPreserved<MachineLoopInfo>();
 1045   Loops = getAnalysisIfAvailable<MachineLoopInfo>();

lib/CodeGen/InlineSpiller.cpp

   91   MachineLoopInfo &Loops;
  145         Loops(pass.getAnalysis<MachineLoopInfo>()), VRM(vrm),
  164   MachineLoopInfo &Loops;
  201         Loops(pass.getAnalysis<MachineLoopInfo>()), VRM(vrm),

lib/CodeGen/LazyMachineBlockFrequencyInfo.cpp

   64   auto *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
   64   auto *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
   82     OwnedMLI = std::make_unique<MachineLoopInfo>();

lib/CodeGen/MachineBasicBlock.cpp

 1075   if (MachineLoopInfo *MLI = P.getAnalysisIfAvailable<MachineLoopInfo>())
 1075   if (MachineLoopInfo *MLI = P.getAnalysisIfAvailable<MachineLoopInfo>())

lib/CodeGen/MachineBlockFrequencyInfo.cpp

  178       MachineLoopInfo &MLI) : MachineFunctionPass(ID) {
  186   AU.addRequired<MachineLoopInfo>();
  193     const MachineLoopInfo &MLI) {
  212   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
  212   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();

lib/CodeGen/MachineBlockPlacement.cpp

  349   MachineLoopInfo *MLI;
  539     AU.addRequired<MachineLoopInfo>();
 2987   MLI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/MachineCombiner.cpp

   66   MachineLoopInfo *MLI; // Current MachineLoopInfo
  130   AU.addRequired<MachineLoopInfo>();
  131   AU.addPreserved<MachineLoopInfo>();
  639   MLI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/MachineLICM.cpp

  104     MachineLoopInfo      *MLI;     // Current MachineLoopInfo
  152       AU.addRequired<MachineLoopInfo>();
  155       AU.addPreserved<MachineLoopInfo>();
  336   MLI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/MachineLoopInfo.cpp

   36 char &llvm::MachineLoopInfoID = MachineLoopInfo::ID;

lib/CodeGen/MachinePipeliner.cpp

  218   MLI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/MachineScheduler.cpp

  216   AU.addRequired<MachineLoopInfo>();
  240   AU.addRequired<MachineLoopInfo>();
  374   MLI = &getAnalysis<MachineLoopInfo>();
  413   MLI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/MachineSink.cpp

   90     MachineLoopInfo *LI;
  125       AU.addRequired<MachineLoopInfo>();
  127       AU.addPreserved<MachineLoopInfo>();
  311   LI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/MachineTraceMetrics.cpp

   61   AU.addRequired<MachineLoopInfo>();
   71   Loops = &getAnalysis<MachineLoopInfo>();
  429   const MachineLoopInfo *Loops;
  433              const MachineLoopInfo *loops) : Blocks(blocks), Loops(loops) {}

lib/CodeGen/ModuloSchedule.cpp

 1939     AU.addRequired<MachineLoopInfo>();
 1956   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
 1956   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();

lib/CodeGen/PHIElimination.cpp

   99                        MachineLoopInfo *MLI);
  143   AU.addPreserved<MachineLoopInfo>();
  159     MachineLoopInfo *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
  159     MachineLoopInfo *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
  564                                    MachineLoopInfo *MLI) {

lib/CodeGen/PeepholeOptimizer.cpp

  158     MachineLoopInfo *MLI;
  172       AU.addRequired<MachineLoopInfo>();
  173       AU.addPreserved<MachineLoopInfo>();
 1607   MLI = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/PostRASchedulerList.cpp

   93       AU.addRequired<MachineLoopInfo>();
   94       AU.addPreserved<MachineLoopInfo>();
  147         MachineFunction &MF, MachineLoopInfo &MLI, AliasAnalysis *AA,
  206     MachineFunction &MF, MachineLoopInfo &MLI, AliasAnalysis *AA,
  286   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
  286   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();

lib/CodeGen/PrologEpilogInserter.cpp

  163   AU.addPreserved<MachineLoopInfo>();

lib/CodeGen/RegAllocBasic.cpp

  187   AU.addRequired<MachineLoopInfo>();
  188   AU.addPreserved<MachineLoopInfo>();
  315                                 getAnalysis<MachineLoopInfo>(),

lib/CodeGen/RegAllocGreedy.cpp

  170   MachineLoopInfo *Loops;
  620   AU.addRequired<MachineLoopInfo>();
  621   AU.addPreserved<MachineLoopInfo>();
 1521   VirtRegAuxInfo VRAI(*MF, *LIS, VRM, getAnalysis<MachineLoopInfo>(), *MBFI);
 1564     VirtRegAuxInfo VRAI(*MF, *LIS, VRM, getAnalysis<MachineLoopInfo>(), *MBFI);
 3237   Loops = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/RegAllocPBQP.cpp

  546   au.addRequired<MachineLoopInfo>();
  547   au.addPreserved<MachineLoopInfo>();
  796   calculateSpillWeightsAndHints(LIS, MF, &VRM, getAnalysis<MachineLoopInfo>(),

lib/CodeGen/RegisterCoalescer.cpp

  129     const MachineLoopInfo* Loops;
  538   AU.addRequired<MachineLoopInfo>();
  539   AU.addPreserved<MachineLoopInfo>();
 3684   Loops = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/ShrinkWrap.cpp

  131   MachineLoopInfo *MLI;
  194     MLI = &getAnalysis<MachineLoopInfo>();
  228     AU.addRequired<MachineLoopInfo>();

lib/CodeGen/SpillPlacement.cpp

   66   AU.addRequiredTransitive<MachineLoopInfo>();
  199   loops = &getAnalysis<MachineLoopInfo>();

lib/CodeGen/SpillPlacement.h

   47   const MachineLoopInfo *loops;

lib/CodeGen/SplitKit.cpp

  152                              const MachineLoopInfo &mli)
  897   const MachineLoopInfo &Loops = SA.Loops;

lib/CodeGen/SplitKit.h

  100   const MachineLoopInfo &Loops;
  169                 const MachineLoopInfo &mli);

lib/CodeGen/UnreachableBlockElim.cpp

   97   AU.addPreserved<MachineLoopInfo>();
  109   MachineLoopInfo *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
  109   MachineLoopInfo *MLI = getAnalysisIfAvailable<MachineLoopInfo>();

lib/CodeGen/XRayInstrumentation.cpp

   54     AU.addPreserved<MachineLoopInfo>();
  172     auto *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
  172     auto *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
  173     MachineLoopInfo ComputedMLI;

lib/Target/AArch64/AArch64ConditionalCompares.cpp

  770   MachineLoopInfo *Loops;
  813   AU.addRequired<MachineLoopInfo>();
  814   AU.addPreserved<MachineLoopInfo>();
  939   Loops = getAnalysisIfAvailable<MachineLoopInfo>();

lib/Target/AArch64/AArch64FalkorHWPFFix.cpp

  193     AU.addRequired<MachineLoopInfo>();
  828   MachineLoopInfo &LI = getAnalysis<MachineLoopInfo>();
  828   MachineLoopInfo &LI = getAnalysis<MachineLoopInfo>();

lib/Target/AMDGPU/AMDILCFGStructurizer.cpp

  141     AU.addRequired<MachineLoopInfo>();
  160     MLI = &getAnalysis<MachineLoopInfo>();
  175   MachineLoopInfo *MLI;
  195   static void PrintLoopinfo(const MachineLoopInfo &LoopInfo) {
  718   for (MachineLoopInfo::iterator It = MLI->begin(),

lib/Target/AMDGPU/GCNRegBankReassign.cpp

  128     AU.addRequired<MachineLoopInfo>();
  143   MachineLoopInfo *MLI;
  734   MLI = &getAnalysis<MachineLoopInfo>();

lib/Target/AMDGPU/R600OptimizeVectorRegisters.cpp

  128     AU.addRequired<MachineLoopInfo>();
  129     AU.addPreserved<MachineLoopInfo>();

lib/Target/AMDGPU/R600Packetizer.cpp

   45     AU.addRequired<MachineLoopInfo>();
   46     AU.addPreserved<MachineLoopInfo>();
  148                      MachineLoopInfo &MLI)
  329   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
  329   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();

lib/Target/ARM/ARMLowOverheadLoops.cpp

   49       AU.addRequired<MachineLoopInfo>();
   97   auto &MLI = getAnalysis<MachineLoopInfo>();
   97   auto &MLI = getAnalysis<MachineLoopInfo>();

lib/Target/Hexagon/HexagonEarlyIfConv.cpp

  167       AU.addRequired<MachineLoopInfo>();
  218     MachineLoopInfo *MLI = nullptr;
 1057   MLI = &getAnalysis<MachineLoopInfo>();
 1064   for (MachineLoopInfo::iterator I = MLI->begin(), E = MLI->end(); I != E; ++I)

lib/Target/Hexagon/HexagonHardwareLoops.cpp

  101     MachineLoopInfo            *MLI;
  121       AU.addRequired<MachineLoopInfo>();
  384   MLI = &getAnalysis<MachineLoopInfo>();

lib/Target/Hexagon/HexagonSplitDouble.cpp

   74       AU.addRequired<MachineLoopInfo>();
   75       AU.addPreserved<MachineLoopInfo>();
   86     const MachineLoopInfo *MLI;
 1199   MLI = &getAnalysis<MachineLoopInfo>();

lib/Target/Hexagon/HexagonVLIWPacketizer.cpp

   99       AU.addRequired<MachineLoopInfo>();
  101       AU.addPreserved<MachineLoopInfo>();
  133       MachineLoopInfo &MLI, AAResults *AA,
  208   auto &MLI = getAnalysis<MachineLoopInfo>();
  208   auto &MLI = getAnalysis<MachineLoopInfo>();

lib/Target/Hexagon/HexagonVLIWPacketizer.h

   63   const MachineLoopInfo *MLI;
   71   HexagonPacketizerList(MachineFunction &MF, MachineLoopInfo &MLI,

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

  412   MachineLoopInfo &LI = getAnalysis<MachineLoopInfo>();
  412   MachineLoopInfo &LI = getAnalysis<MachineLoopInfo>();

lib/Target/NVPTX/NVPTXAsmPrinter.h

  299     AU.addRequired<MachineLoopInfo>();

lib/Target/SystemZ/SystemZMachineScheduler.h

   32   const MachineLoopInfo *MLI;

lib/Target/WebAssembly/WebAssemblyCFGSort.cpp

   80   const MachineLoopInfo &MLI;
   87   RegionInfo(const MachineLoopInfo &MLI, const WebAssemblyExceptionInfo &WEI)
  120     AU.addRequired<MachineLoopInfo>();
  121     AU.addPreserved<MachineLoopInfo>();
  241 static void sortBlocks(MachineFunction &MF, const MachineLoopInfo &MLI,
  411   const auto &MLI = getAnalysis<MachineLoopInfo>();
  411   const auto &MLI = getAnalysis<MachineLoopInfo>();

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

   46     AU.addRequired<MachineLoopInfo>();
  375   const auto &MLI = getAnalysis<MachineLoopInfo>();
  375   const auto &MLI = getAnalysis<MachineLoopInfo>();

lib/Target/X86/X86CmovConversion.cpp

  154   AU.addRequired<MachineLoopInfo>();
  167   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
  167   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();

lib/Target/X86/X86FixupBWInsts.cpp

  114     AU.addRequired<MachineLoopInfo>(); // Machine loop info is used to
  139   MachineLoopInfo *MLI;
  158   MLI = &getAnalysis<MachineLoopInfo>();

unittests/Target/X86/MachineSizeOptsTest.cpp

   48     std::unique_ptr<MachineLoopInfo> MLI;
   53       MLI.reset(new MachineLoopInfo(*MDT));

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