LCOV - code coverage report
Current view: top level - include/llvm/CodeGen - MachineLoopInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 18 18 100.0 %
Date: 2017-09-14 15:23:50 Functions: 4 5 80.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #include "llvm/IR/DebugLoc.h"
      37             : #include "llvm/Pass.h"
      38             : 
      39             : namespace llvm {
      40             : 
      41             : // Implementation in LoopInfoImpl.h
      42             : class MachineLoop;
      43             : extern template class LoopBase<MachineBasicBlock, MachineLoop>;
      44             : 
      45       44198 : class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
      46             : public:
      47             :   MachineLoop();
      48             : 
      49             :   /// Return the "top" block in the loop, which is the first block in the linear
      50             :   /// layout, ignoring any parts of the loop not contiguous with the part that
      51             :   /// contains the header.
      52             :   MachineBasicBlock *getTopBlock();
      53             : 
      54             :   /// Return the "bottom" block in the loop, which is the last block in the
      55             :   /// linear layout, ignoring any parts of the loop not contiguous with the part
      56             :   /// that contains the header.
      57             :   MachineBasicBlock *getBottomBlock();
      58             : 
      59             :   /// \brief Find the block that contains the loop control variable and the
      60             :   /// loop test. This will return the latch block if it's one of the exiting
      61             :   /// blocks. Otherwise, return the exiting block. Return 'null' when
      62             :   /// multiple exiting blocks are present.
      63             :   MachineBasicBlock *findLoopControlBlock();
      64             : 
      65             :   /// Return the debug location of the start of this loop.
      66             :   /// This looks for a BB terminating instruction with a known debug
      67             :   /// location by looking at the preheader and header blocks. If it
      68             :   /// cannot find a terminating instruction with location information,
      69             :   /// it returns an unknown location.
      70             :   DebugLoc getStartLoc() const;
      71             : 
      72             :   void dump() const;
      73             : 
      74             : private:
      75             :   friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
      76             : 
      77             :   explicit MachineLoop(MachineBasicBlock *MBB)
      78       44198 :     : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
      79             : };
      80             : 
      81             : // Implementation in LoopInfoImpl.h
      82             : extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
      83             : 
      84      104582 : 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      210364 :   MachineLoopInfo() : MachineFunctionPass(ID) {
      93      105182 :     initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
      94      105182 :   }
      95             :   MachineLoopInfo(const MachineLoopInfo &) = delete;
      96             :   MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
      97             : 
      98         946 :   LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
      99             : 
     100             :   /// \brief Find the block that either is the loop preheader, or could
     101             :   /// speculatively be used as the preheader. This is e.g. useful to place
     102             :   /// loop setup code. Code that cannot be speculated should not be placed
     103             :   /// here. SpeculativePreheader is controlling whether it also tries to
     104             :   /// find the speculative preheader if the regular preheader is not present.
     105             :   MachineBasicBlock *findLoopPreheader(MachineLoop *L,
     106             :                                        bool SpeculativePreheader = false) const;
     107             : 
     108             :   /// The iterator interface to the top-level loops in the current function.
     109             :   using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
     110     1063148 :   inline iterator begin() const { return LI.begin(); }
     111     1063148 :   inline iterator end() const { return LI.end(); }
     112     1140492 :   bool empty() const { return LI.empty(); }
     113             : 
     114             :   /// Return the innermost loop that BB lives in. If a basic block is in no loop
     115             :   /// (for example the entry node), null is returned.
     116             :   inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
     117     5831016 :     return LI.getLoopFor(BB);
     118             :   }
     119             : 
     120             :   /// Same as getLoopFor.
     121             :   inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
     122             :     return LI.getLoopFor(BB);
     123             :   }
     124             : 
     125             :   /// Return the loop nesting level of the specified block.
     126             :   inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
     127      348547 :     return LI.getLoopDepth(BB);
     128             :   }
     129             : 
     130             :   /// True if the block is a loop header node.
     131             :   inline bool isLoopHeader(const MachineBasicBlock *BB) const {
     132      295467 :     return LI.isLoopHeader(BB);
     133             :   }
     134             : 
     135             :   /// Calculate the natural loop information.
     136             :   bool runOnMachineFunction(MachineFunction &F) override;
     137             : 
     138     1756418 :   void releaseMemory() override { LI.releaseMemory(); }
     139             : 
     140             :   void getAnalysisUsage(AnalysisUsage &AU) const override;
     141             : 
     142             :   /// This removes the specified top-level loop from this loop info object. The
     143             :   /// loop is not deleted, as it will presumably be inserted into another loop.
     144             :   inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
     145             : 
     146             :   /// Change the top-level loop that contains BB to the specified loop. This
     147             :   /// should be used by transformations that restructure the loop hierarchy
     148             :   /// tree.
     149             :   inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
     150           2 :     LI.changeLoopFor(BB, L);
     151             :   }
     152             : 
     153             :   /// Replace the specified loop in the top-level loops list with the indicated
     154             :   /// loop.
     155             :   inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
     156             :     LI.changeTopLevelLoop(OldLoop, NewLoop);
     157             :   }
     158             : 
     159             :   /// This adds the specified loop to the collection of top-level loops.
     160             :   inline void addTopLevelLoop(MachineLoop *New) {
     161             :     LI.addTopLevelLoop(New);
     162             :   }
     163             : 
     164             :   /// This method completely removes BB from all data structures, including all
     165             :   /// of the Loop objects it is nested in and our mapping from
     166             :   /// MachineBasicBlocks to loops.
     167             :   void removeBlock(MachineBasicBlock *BB) {
     168         868 :     LI.removeBlock(BB);
     169             :   }
     170             : };
     171             : 
     172             : // Allow clients to walk the list of nested loops...
     173             : template <> struct GraphTraits<const MachineLoop*> {
     174             :   using NodeRef = const MachineLoop *;
     175             :   using ChildIteratorType = MachineLoopInfo::iterator;
     176             : 
     177             :   static NodeRef getEntryNode(const 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             : template <> struct GraphTraits<MachineLoop*> {
     183             :   using NodeRef = MachineLoop *;
     184             :   using ChildIteratorType = MachineLoopInfo::iterator;
     185             : 
     186             :   static NodeRef getEntryNode(MachineLoop *L) { return L; }
     187         216 :   static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
     188         240 :   static ChildIteratorType child_end(NodeRef N) { return N->end(); }
     189             : };
     190             : 
     191             : } // end namespace llvm
     192             : 
     193             : #endif // LLVM_CODEGEN_MACHINELOOPINFO_H

Generated by: LCOV version 1.13