contrib/llvm/include/llvm/CodeGen/MachineLoopInfo.h

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