granicus.if.org Git - llvm/blob - include/llvm/CodeGen/MachineLoopInfo.h

   1 //===- llvm/CodeGen/MachineLoopInfo.h - Natural Loop Calculator -*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the MachineLoopInfo class that is used to identify natural
  10 // loops and determine the loop depth of various nodes of the CFG.  Note that
  11 // natural loops may actually be several loops that share the same header node.
  12 //
  13 // This analysis calculates the nesting structure of loops in a function.  For
  14 // each natural loop identified, this analysis identifies natural loops
  15 // contained entirely within the loop and the basic blocks the make up the loop.
  16 //
  17 // It can calculate on the fly various bits of information, for example:
  18 //
  19 //  * whether there is a preheader for the loop
  20 //  * the number of back edges to the header
  21 //  * whether or not a particular block branches out of the loop
  22 //  * the successor blocks of the loop
  23 //  * the loop depth
  24 //  * the trip count
  25 //  * etc...
  26 //
  27 //===----------------------------------------------------------------------===//
  28
  29 #ifndef LLVM_CODEGEN_MACHINELOOPINFO_H
  30 #define LLVM_CODEGEN_MACHINELOOPINFO_H
  31
  32 #include "llvm/Analysis/LoopInfo.h"
  33 #include "llvm/CodeGen/MachineBasicBlock.h"
  34 #include "llvm/CodeGen/MachineFunctionPass.h"
  35 #include "llvm/IR/DebugLoc.h"
  36 #include "llvm/Pass.h"
  37
  38 namespace llvm {
  39
  40 class MachineDominatorTree;
  41 // Implementation in LoopInfoImpl.h
  42 class MachineLoop;
  43 extern template class LoopBase<MachineBasicBlock, MachineLoop>;
  44
  45 class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
  46 public:
  47   /// Return the "top" block in the loop, which is the first block in the linear
  48   /// layout, ignoring any parts of the loop not contiguous with the part that
  49   /// contains the header.
  50   MachineBasicBlock *getTopBlock();
  51
  52   /// Return the "bottom" block in the loop, which is the last block in the
  53   /// linear layout, ignoring any parts of the loop not contiguous with the part
  54   /// that contains the header.
  55   MachineBasicBlock *getBottomBlock();
  56
  57   /// Find the block that contains the loop control variable and the
  58   /// loop test. This will return the latch block if it's one of the exiting
  59   /// blocks. Otherwise, return the exiting block. Return 'null' when
  60   /// multiple exiting blocks are present.
  61   MachineBasicBlock *findLoopControlBlock();
  62
  63   /// Return the debug location of the start of this loop.
  64   /// This looks for a BB terminating instruction with a known debug
  65   /// location by looking at the preheader and header blocks. If it
  66   /// cannot find a terminating instruction with location information,
  67   /// it returns an unknown location.
  68   DebugLoc getStartLoc() const;
  69
  70   void dump() const;
  71
  72 private:
  73   friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
  74
  75   explicit MachineLoop(MachineBasicBlock *MBB)
  76     : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
  77
  78   MachineLoop() = default;
  79 };
  80
  81 // Implementation in LoopInfoImpl.h
  82 extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
  83
  84 class MachineLoopInfo : public MachineFunctionPass {
  85   friend class LoopBase<MachineBasicBlock, MachineLoop>;
  86
  87   LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
  88
  89 public:
  90   static char ID; // Pass identification, replacement for typeid
  91
  92   MachineLoopInfo() : MachineFunctionPass(ID) {
  93     initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
  94   }
  95   explicit MachineLoopInfo(MachineDominatorTree &MDT)
  96       : MachineFunctionPass(ID) {
  97     calculate(MDT);
  98   }
  99   MachineLoopInfo(const MachineLoopInfo &) = delete;
 100   MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
 101
 102   LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
 103
 104   /// Find the block that either is the loop preheader, or could
 105   /// speculatively be used as the preheader. This is e.g. useful to place
 106   /// loop setup code. Code that cannot be speculated should not be placed
 107   /// here. SpeculativePreheader is controlling whether it also tries to
 108   /// find the speculative preheader if the regular preheader is not present.
 109   MachineBasicBlock *findLoopPreheader(MachineLoop *L,
 110                                        bool SpeculativePreheader = false) const;
 111
 112   /// The iterator interface to the top-level loops in the current function.
 113   using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
 114   inline iterator begin() const { return LI.begin(); }
 115   inline iterator end() const { return LI.end(); }
 116   bool empty() const { return LI.empty(); }
 117
 118   /// Return the innermost loop that BB lives in. If a basic block is in no loop
 119   /// (for example the entry node), null is returned.
 120   inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
 121     return LI.getLoopFor(BB);
 122   }
 123
 124   /// Same as getLoopFor.
 125   inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
 126     return LI.getLoopFor(BB);
 127   }
 128
 129   /// Return the loop nesting level of the specified block.
 130   inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
 131     return LI.getLoopDepth(BB);
 132   }
 133
 134   /// True if the block is a loop header node.
 135   inline bool isLoopHeader(const MachineBasicBlock *BB) const {
 136     return LI.isLoopHeader(BB);
 137   }
 138
 139   /// Calculate the natural loop information.
 140   bool runOnMachineFunction(MachineFunction &F) override;
 141   void calculate(MachineDominatorTree &MDT);
 142
 143   void releaseMemory() override { LI.releaseMemory(); }
 144
 145   void getAnalysisUsage(AnalysisUsage &AU) const override;
 146
 147   /// This removes the specified top-level loop from this loop info object. The
 148   /// loop is not deleted, as it will presumably be inserted into another loop.
 149   inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
 150
 151   /// Change the top-level loop that contains BB to the specified loop. This
 152   /// should be used by transformations that restructure the loop hierarchy
 153   /// tree.
 154   inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
 155     LI.changeLoopFor(BB, L);
 156   }
 157
 158   /// Replace the specified loop in the top-level loops list with the indicated
 159   /// loop.
 160   inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
 161     LI.changeTopLevelLoop(OldLoop, NewLoop);
 162   }
 163
 164   /// This adds the specified loop to the collection of top-level loops.
 165   inline void addTopLevelLoop(MachineLoop *New) {
 166     LI.addTopLevelLoop(New);
 167   }
 168
 169   /// This method completely removes BB from all data structures, including all
 170   /// of the Loop objects it is nested in and our mapping from
 171   /// MachineBasicBlocks to loops.
 172   void removeBlock(MachineBasicBlock *BB) {
 173     LI.removeBlock(BB);
 174   }
 175 };
 176
 177 // Allow clients to walk the list of nested loops...
 178 template <> struct GraphTraits<const MachineLoop*> {
 179   using NodeRef = const MachineLoop *;
 180   using ChildIteratorType = MachineLoopInfo::iterator;
 181
 182   static NodeRef getEntryNode(const MachineLoop *L) { return L; }
 183   static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
 184   static ChildIteratorType child_end(NodeRef N) { return N->end(); }
 185 };
 186
 187 template <> struct GraphTraits<MachineLoop*> {
 188   using NodeRef = MachineLoop *;
 189   using ChildIteratorType = MachineLoopInfo::iterator;
 190
 191   static NodeRef getEntryNode(MachineLoop *L) { return L; }
 192   static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
 193   static ChildIteratorType child_end(NodeRef N) { return N->end(); }
 194 };
 195
 196 } // end namespace llvm
 197
 198 #endif // LLVM_CODEGEN_MACHINELOOPINFO_H