|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/BlockFrequencyInfoImpl.h 58 class MachineLoop;
include/llvm/CodeGen/MachineLoopInfo.h 42 class MachineLoop;
include/llvm/CodeGen/MachineTraceMetrics.h 63 class MachineLoop;
include/llvm/CodeGen/TargetInstrInfo.h 46 class MachineLoop;
include/llvm/CodeGen/TargetLowering.h 84 class MachineLoop;
References
include/llvm/ADT/STLExtras.h 154 auto adl_begin(ContainerTy &&container)
162 auto adl_end(ContainerTy &&container)
178 auto adl_begin(ContainerTy &&container)
184 auto adl_end(ContainerTy &&container)
1224 bool is_contained(R &&Range, const E &Element) {
include/llvm/Analysis/BlockFrequencyInfoImpl.h 556 using LoopT = MachineLoop;
include/llvm/Analysis/CFG.h 150 for (const auto *Lp = LI.getLoopFor(Src); Lp; Lp = Lp->getParentLoop()) {
include/llvm/Analysis/LoopInfo.h 75 LoopT *ParentLoop;
77 std::vector<LoopT *> SubLoops;
89 LoopBase(const LoopBase<BlockT, LoopT> &) = delete;
90 const LoopBase<BlockT, LoopT> &
91 operator=(const LoopBase<BlockT, LoopT> &) = delete;
100 for (const LoopT *CurLoop = ParentLoop; CurLoop;
106 LoopT *getParentLoop() const { return ParentLoop; }
109 void setParentLoop(LoopT *L) {
115 bool contains(const LoopT *L) const {
131 template <class InstT> bool contains(const InstT *Inst) const {
136 const std::vector<LoopT *> &getSubLoops() const {
140 std::vector<LoopT *> &getSubLoopsVector() {
144 typedef typename std::vector<LoopT *>::const_iterator iterator;
146 typename std::vector<LoopT *>::const_reverse_iterator reverse_iterator;
325 static void getInnerLoopsInPreorder(const LoopT &L,
327 SmallVector<LoopT *, 4> PreOrderWorklist;
331 LoopT *L = PreOrderWorklist.pop_back_val();
341 SmallVector<const LoopT *, 4> getLoopsInPreorder() const {
342 SmallVector<const LoopT *, 4> PreOrderLoops;
343 const LoopT *CurLoop = static_cast<const LoopT *>(this);
348 SmallVector<LoopT *, 4> getLoopsInPreorder() {
349 SmallVector<LoopT *, 4> PreOrderLoops;
350 LoopT *CurLoop = static_cast<LoopT *>(this);
365 void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase<BlockT, LoopT> &LI);
371 void replaceChildLoopWith(LoopT *OldChild, LoopT *NewChild);
371 void replaceChildLoopWith(LoopT *OldChild, LoopT *NewChild);
375 void addChildLoop(LoopT *NewChild) {
384 LoopT *removeChildLoop(iterator I) {
387 LoopT *Child = *I;
396 LoopT *removeChildLoop(LoopT *Child) {
396 LoopT *removeChildLoop(LoopT *Child) {
453 void verifyLoopNest(DenseSet<const LoopT *> *Loops) const;
485 for (auto *SubLoop : SubLoops)
499 raw_ostream &operator<<(raw_ostream &OS, const LoopBase<BlockT, LoopT> &Loop) {
850 DenseMap<const BlockT *, LoopT *> BBMap;
851 std::vector<LoopT *> TopLevelLoops;
874 for (auto *L : TopLevelLoops)
886 for (auto *L : TopLevelLoops)
892 template <typename... ArgsTy> LoopT *AllocateLoop(ArgsTy &&... Args) {
893 LoopT *Storage = LoopAllocator.Allocate<LoopT>();
893 LoopT *Storage = LoopAllocator.Allocate<LoopT>();
894 return new (Storage) LoopT(std::forward<ArgsTy>(Args)...);
900 typedef typename std::vector<LoopT *>::const_iterator iterator;
902 typename std::vector<LoopT *>::const_reverse_iterator reverse_iterator;
914 SmallVector<LoopT *, 4> getLoopsInPreorder();
924 SmallVector<LoopT *, 4> getLoopsInReverseSiblingPreorder();
928 LoopT *getLoopFor(const BlockT *BB) const { return BBMap.lookup(BB); }
931 const LoopT *operator[](const BlockT *BB) const { return getLoopFor(BB); }
936 const LoopT *L = getLoopFor(BB);
942 const LoopT *L = getLoopFor(BB);
949 LoopT *removeLoop(iterator I) {
951 LoopT *L = *I;
960 void changeLoopFor(BlockT *BB, LoopT *L) {
970 void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop) {
970 void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop) {
979 void addTopLevelLoop(LoopT *New) {
990 for (LoopT *L = I->second; L; L = L->getParentLoop())
999 static bool isNotAlreadyContainedIn(const LoopT *SubLoop,
1000 const LoopT *ParentLoop) {
1026 void destroy(LoopT *L) {
include/llvm/Analysis/LoopInfoImpl.h 248 LoopT *L = static_cast<LoopT *>(this);
270 typename std::vector<LoopT *>::iterator I = find(SubLoops, OldChild);
418 static void discoverAndMapSubloop(LoopT *L, ArrayRef<BlockT *> Backedges,
419 LoopInfoBase<BlockT, LoopT> *LI,
432 LoopT *Subloop = LI->getLoopFor(PredBB);
448 while (LoopT *Parent = Subloop->getParentLoop())
479 LoopInfoBase<BlockT, LoopT> *LI;
482 PopulateLoopsDFS(LoopInfoBase<BlockT, LoopT> *li) : LI(li) {}
502 LoopT *Subloop = LI->getLoopFor(Block);
556 LoopT *L = AllocateLoop(Header);
562 PopulateLoopsDFS<BlockT, LoopT> DFS(this);
568 SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;
574 for (LoopT *RootL : reverse(*this)) {
586 SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;
592 for (LoopT *RootL : *this) {
597 LoopT *L = PreOrderWorklist.pop_back_val();
629 void addInnerLoopsToHeadersMap(DenseMap<BlockT *, const LoopT *> &LoopHeaders,
630 const LoopInfoBase<BlockT, LoopT> &LI,
631 const LoopT &L) {
633 for (LoopT *SL : L)
639 static void compareLoops(const LoopT *L, const LoopT *OtherL,
639 static void compareLoops(const LoopT *L, const LoopT *OtherL,
640 DenseMap<BlockT *, const LoopT *> &OtherLoopHeaders) {
648 const LoopT *ParentL = L, *OtherParentL = OtherL;
656 for (const LoopT *SubL : *L) {
658 const LoopT *OtherSubL = OtherLoopHeaders.lookup(SubH);
683 DenseSet<const LoopT *> Loops;
693 LoopT *L = Entry.second;
696 for (LoopT *ChildLoop : *L)
702 LoopInfoBase<BlockT, LoopT> OtherLI;
708 DenseMap<BlockT *, const LoopT *> OtherLoopHeaders;
709 for (LoopT *L : OtherLI)
715 for (LoopT *L : *this) {
717 const LoopT *OtherL = OtherLoopHeaders.lookup(Header);
include/llvm/CodeGen/MachineLoopInfo.h 45 class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
87 LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
102 LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
109 MachineBasicBlock *findLoopPreheader(MachineLoop *L,
113 using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
120 inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
125 inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
149 inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
154 inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
160 inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
160 inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
165 inline void addTopLevelLoop(MachineLoop *New) {
179 using NodeRef = const MachineLoop *;
182 static NodeRef getEntryNode(const MachineLoop *L) { return L; }
188 using NodeRef = MachineLoop *;
191 static NodeRef getEntryNode(MachineLoop *L) { return L; }
include/llvm/CodeGen/MachinePipeliner.h 103 bool canPipelineLoop(MachineLoop &L);
104 bool scheduleLoop(MachineLoop &L);
105 bool swingModuloScheduler(MachineLoop &L);
106 void setPragmaPipelineOptions(MachineLoop &L);
119 MachineLoop &Loop;
199 SwingSchedulerDAG(MachinePipeliner &P, MachineLoop &L, LiveIntervals &lis,
include/llvm/CodeGen/MachineRegionInfo.h 41 using LoopT = MachineLoop;
include/llvm/CodeGen/MachineTraceMetrics.h 345 const MachineLoop *getLoopFor(const MachineBasicBlock*) const;
include/llvm/CodeGen/ModuloSchedule.h 81 MachineLoop *Loop;
105 ModuloSchedule(MachineFunction &MF, MachineLoop *Loop,
118 MachineLoop *getLoop() const { return Loop; }
include/llvm/CodeGen/TargetInstrInfo.h 714 virtual bool analyzeLoop(MachineLoop &L, MachineInstr *&IndVarInst,
include/llvm/CodeGen/TargetLowering.h 1616 virtual Align getPrefLoopAlignment(MachineLoop *ML = nullptr) const {
include/llvm/Support/Allocator.h 81 template <typename T> T *Allocate(size_t Num = 1) {
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
88 !std::is_same<typename std::remove_cv<T>::type, void>::value, void>::type
89 Deallocate(T *Ptr, size_t Num = 1) {
90 Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 2842 static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop,
2854 static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop,
2857 for (const MachineLoop *CL : *Loop) {
2871 const MachineLoop *Loop = LI->getLoopFor(&MBB);
lib/CodeGen/BranchFolding.cpp 474 if (MachineLoop *ML = MLI->getLoopFor(&CurMBB))
1128 MachineLoop *ML;
lib/CodeGen/CalcSpillWeights.cpp 156 MachineLoop *loop = nullptr;
lib/CodeGen/MachineBasicBlock.cpp 1076 if (MachineLoop *TIL = MLI->getLoopFor(this)) {
1079 if (MachineLoop *DestLoop = MLI->getLoopFor(Succ)) {
1096 if (MachineLoop *P = DestLoop->getParentLoop())
lib/CodeGen/MachineBlockPlacement.cpp 466 const MachineLoop &L, const BlockFilterSet &LoopBlockSet);
468 const MachineLoop &L, const BlockFilterSet &LoopBlockSet);
470 const MachineLoop &L, const BlockFilterSet &LoopBlockSet,
472 BlockFilterSet collectLoopBlockSet(const MachineLoop &L);
473 void buildLoopChains(const MachineLoop &L);
478 BlockChain &LoopChain, const MachineLoop &L,
1954 const MachineLoop &L,
2019 MachineBlockPlacement::findBestLoopTop(const MachineLoop &L,
2048 MachineBlockPlacement::findBestLoopExit(const MachineLoop &L,
2109 if (MachineLoop *ExitLoop = MLI->getLoopFor(Succ)) {
2289 BlockChain &LoopChain, const MachineLoop &L,
2427 MachineBlockPlacement::collectLoopBlockSet(const MachineLoop &L) {
2464 void MachineBlockPlacement::buildLoopChains(const MachineLoop &L) {
2467 for (const MachineLoop *InnerLoop : L)
2593 for (MachineLoop *L : *MLI)
2763 MachineLoop *L = MLI->getLoopFor(ChainBB);
lib/CodeGen/MachineCombiner.cpp 503 const MachineLoop *ML = MLI->getLoopFor(MBB);
lib/CodeGen/MachineLICM.cpp 110 MachineLoop *CurLoop; // The current loop we are working on.
292 static bool LoopIsOuterMostWithPredecessor(MachineLoop *CurLoop) {
297 for (MachineLoop *L = CurLoop->getParentLoop(); L; L = L->getParentLoop())
340 SmallVector<MachineLoop *, 8> Worklist(MLI->begin(), MLI->end());
505 const MachineLoop *ML = MLI->getLoopFor(BB);
689 const MachineLoop *ML = MLI->getLoopFor(BB);
lib/CodeGen/MachineLoopInfo.cpp 111 MachineLoopInfo::findLoopPreheader(MachineLoop *L,
138 MachineLoop *T = getLoopFor(S);
lib/CodeGen/MachinePipeliner.cpp 233 bool MachinePipeliner::scheduleLoop(MachineLoop &L) {
261 void MachinePipeliner::setPragmaPipelineOptions(MachineLoop &L) {
308 bool MachinePipeliner::canPipelineLoop(MachineLoop &L) {
382 bool MachinePipeliner::swingModuloScheduler(MachineLoop &L) {
lib/CodeGen/MachineTraceMetrics.cpp 167 const MachineLoop*
303 static bool isExitingLoop(const MachineLoop *From, const MachineLoop *To) {
303 static bool isExitingLoop(const MachineLoop *From, const MachineLoop *To) {
328 const MachineLoop *CurLoop = getLoopFor(MBB);
356 const MachineLoop *CurLoop = getLoopFor(MBB);
459 if (const MachineLoop *FromLoop = LB.Loops->getLoopFor(*From)) {
596 const MachineLoop *Loop = getLoopFor(MBB);
604 const MachineLoop *Loop = getLoopFor(MBB);
605 const MachineLoop *SuccLoop = getLoopFor(TBI.Succ);
1069 if (const MachineLoop *Loop = getLoopFor(MBB))
lib/CodeGen/ModuloSchedule.cpp 1273 KernelRewriter(MachineLoop &L, ModuloSchedule &S,
1279 KernelRewriter::KernelRewriter(MachineLoop &L, ModuloSchedule &S,
1936 void runOnLoop(MachineFunction &MF, MachineLoop &L);
1957 for (auto *L : MLI) {
1985 void ModuloScheduleTest::runOnLoop(MachineFunction &MF, MachineLoop &L) {
lib/CodeGen/PHIElimination.cpp 568 const MachineLoop *CurLoop = MLI ? MLI->getLoopFor(&MBB) : nullptr;
585 const MachineLoop *PreLoop = MLI ? MLI->getLoopFor(PreMBB) : nullptr;
lib/CodeGen/RegAllocGreedy.cpp 544 void reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
550 for (MachineLoop *L : *Loops) {
3138 void RAGreedy::reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
3148 for (MachineLoop *SubLoop : *L) {
lib/CodeGen/SplitKit.cpp 898 const MachineLoop *DefLoop = Loops.getLoopFor(DefMBB);
906 const MachineLoop *Loop = Loops.getLoopFor(MBB);
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp 203 void runOnLoop(MachineLoop &L, MachineFunction &Fn);
676 void FalkorHWPFFix::runOnLoop(MachineLoop &L, MachineFunction &Fn) {
832 for (MachineLoop *I : LI)
lib/Target/AMDGPU/AMDILCFGStructurizer.cpp 120 using LoopLandInfoMap = std::map<MachineLoop *, MachineBasicBlock *>;
196 for (MachineLoop::iterator iter = LoopInfo.begin(),
204 MachineBasicBlock *getLoopLandInfo(MachineLoop *LoopRep) const;
270 int mergeLoop(MachineLoop *LoopRep);
310 MachineBasicBlock *normalizeInfiniteLoopExit(MachineLoop *LoopRep);
335 std::map<MachineLoop *, bool> Visited;
351 MachineBasicBlock *AMDGPUCFGStructurizer::getLoopLandInfo(MachineLoop *LoopRep)
360 MachineLoop *LoopRep = MLI->getLoopFor(MBB);
375 MachineLoop *LoopRep = MLI->getLoopFor(MBB);
720 MachineLoop *LoopRep = (*It);
1014 std::deque<MachineLoop *> NestedLoops;
1016 for (MachineLoop *ML : depth_first(It))
1026 for (MachineLoop *ExaminedLoop : NestedLoops) {
1038 int AMDGPUCFGStructurizer::mergeLoop(MachineLoop *LoopRep) {
1070 MachineLoop *ParentLoop = LoopRep->getParentLoop();
1082 MachineLoop *LoopRep = MLI->getLoopFor(Src1MBB);
1576 AMDGPUCFGStructurizer::normalizeInfiniteLoopExit(MachineLoop* LoopRep) {
lib/Target/AMDGPU/SIISelLowering.cpp10741 Align SITargetLowering::getPrefLoopAlignment(MachineLoop *ML) const {
10788 for (MachineLoop *P = ML->getParentLoop(); P; P = P->getParentLoop()) {
lib/Target/AMDGPU/SIISelLowering.h 403 Align getPrefLoopAlignment(MachineLoop *ML) const override;
lib/Target/ARM/ARMLowOverheadLoops.cpp 65 bool ProcessLoop(MachineLoop *ML);
77 void Expand(MachineLoop *ML, MachineInstr *Start,
213 bool ARMLowOverheadLoops::ProcessLoop(MachineLoop *ML) {
441 void ARMLowOverheadLoops::Expand(MachineLoop *ML, MachineInstr *Start,
lib/Target/Hexagon/HexagonEarlyIfConv.cpp 177 bool matchFlowPattern(MachineBasicBlock *B, MachineLoop *L,
179 bool visitBlock(MachineBasicBlock *B, MachineLoop *L);
180 bool visitLoop(MachineLoop *L);
234 MachineLoop *L = MLI->getLoopFor(SB);
239 MachineLoop *L, FlowPattern &FP) {
597 MachineLoop *L) {
643 bool HexagonEarlyIfConversion::visitLoop(MachineLoop *L) {
650 for (MachineLoop::iterator I = L->begin(), E = L->end(); I != E; ++I)
lib/Target/Hexagon/HexagonHardwareLoops.cpp 182 bool findInductionRegister(MachineLoop *L, unsigned &Reg,
194 CountValue *getLoopTripCount(MachineLoop *L,
204 CountValue *computeCount(MachineLoop *Loop, const MachineOperand *Start,
215 bool containsInvalidInstruction(MachineLoop *L, bool IsInnerHWLoop) const;
219 bool convertToHardwareLoop(MachineLoop *L, bool &L0used, bool &L1used);
237 bool isLoopFeeder(MachineLoop *L, MachineBasicBlock *A, MachineInstr *MI,
244 MachineBasicBlock *MBB, MachineLoop *L,
251 MachineBasicBlock *MBB, MachineLoop *L,
297 bool fixupInductionVariable(MachineLoop *L);
301 MachineBasicBlock *createPreheaderForLoop(MachineLoop *L);
401 bool HexagonHardwareLoops::findInductionRegister(MachineLoop *L,
565 CountValue *HexagonHardwareLoops::getLoopTripCount(MachineLoop *L,
724 CountValue *HexagonHardwareLoops::computeCount(MachineLoop *Loop,
1011 bool HexagonHardwareLoops::containsInvalidInstruction(MachineLoop *L,
1123 bool HexagonHardwareLoops::convertToHardwareLoop(MachineLoop *L,
1134 for (MachineLoop::iterator I = L->begin(), E = L->end(); I != E; ++I) {
1364 bool HexagonHardwareLoops::isLoopFeeder(MachineLoop *L, MachineBasicBlock *A,
1388 MachineLoop *L, LoopFeederMap &LoopFeederPhi) const {
1416 MachineBasicBlock *MBB, MachineLoop *L,
1606 bool HexagonHardwareLoops::fixupInductionVariable(MachineLoop *L) {
1849 MachineLoop *L) {
1991 MachineLoop *ParentLoop = L->getParentLoop();
lib/Target/Hexagon/HexagonSplitDouble.cpp 93 using LoopRegMap = std::map<const MachineLoop *, USet>;
103 void collectIndRegsForLoop(const MachineLoop *L, USet &Rs);
455 const MachineLoop *L = MLI->getLoopFor(PB);
476 void HexagonSplitDoubleRegs::collectIndRegsForLoop(const MachineLoop *L,
573 using LoopVector = std::vector<MachineLoop *>;
586 MachineLoop *L = WorkQ[i];
lib/Target/PowerPC/PPCISelLowering.cpp14167 Align PPCTargetLowering::getPrefLoopAlignment(MachineLoop *ML) const {
lib/Target/PowerPC/PPCISelLowering.h 748 Align getPrefLoopAlignment(MachineLoop *ML) const override;
lib/Target/SystemZ/SystemZMachineScheduler.cpp 41 const MachineLoop *Loop) {
lib/Target/WebAssembly/WebAssemblyCFGSort.cpp 60 const T *Region;
63 ConcreteRegion(const T *Region) : Region(Region) {}
83 DenseMap<const MachineLoop *, std::unique_ptr<Region>> LoopMap;
92 const auto *ML = MLI.getLoopFor(MBB);
100 LoopMap[ML] = std::make_unique<ConcreteRegion<MachineLoop>>(ML);
250 if (MachineLoop *L = MLI.getLoopFor(&MBB))
296 if (MachineLoop *SuccL = MLI.getLoopFor(Succ))
lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp 378 MachineLoop *Loop = MLI.getLoopFor(&MBB);
lib/Target/WebAssembly/WebAssemblyUtilities.h 39 template <typename T> MachineBasicBlock *getBottom(const T *Unit) {
lib/Target/X86/X86CmovConversion.cpp 223 SmallVector<MachineLoop *, 4> Loops(MLI.begin(), MLI.end());
227 for (MachineLoop *Child : Loops[i]->getSubLoops())
230 for (MachineLoop *CurrLoop : Loops) {
lib/Target/X86/X86FixupBWInsts.cpp 371 if (MachineLoop *ML = MLI->getLoopFor(&MBB))
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/bits/range_access.h 48 begin(_Container& __cont) -> decltype(__cont.begin())
58 begin(const _Container& __cont) -> decltype(__cont.begin())
68 end(_Container& __cont) -> decltype(__cont.end())
78 end(const _Container& __cont) -> decltype(__cont.end())
usr/include/c++/7.4.0/type_traits 1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1633 { typedef _Tp type; };
1983 { typedef _Up type; };