LCOV - code coverage report
Current view: top level - lib/CodeGen - MachineLoopInfo.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 41 55 74.5 %
Date: 2017-09-14 15:23:50 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- MachineLoopInfo.cpp - Natural Loop Calculator ----------------------===//
       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             : // the loops identified may actually be several natural loops that share the
      13             : // same header node... not just a single natural loop.
      14             : //
      15             : //===----------------------------------------------------------------------===//
      16             : 
      17             : #include "llvm/CodeGen/MachineLoopInfo.h"
      18             : #include "llvm/Analysis/LoopInfoImpl.h"
      19             : #include "llvm/CodeGen/MachineDominators.h"
      20             : #include "llvm/CodeGen/Passes.h"
      21             : #include "llvm/Support/Debug.h"
      22             : #include "llvm/Support/raw_ostream.h"
      23             : using namespace llvm;
      24             : 
      25             : // Explicitly instantiate methods in LoopInfoImpl.h for MI-level Loops.
      26             : template class llvm::LoopBase<MachineBasicBlock, MachineLoop>;
      27             : template class llvm::LoopInfoBase<MachineBasicBlock, MachineLoop>;
      28             : 
      29             : char MachineLoopInfo::ID = 0;
      30       53279 : INITIALIZE_PASS_BEGIN(MachineLoopInfo, "machine-loops",
      31             :                 "Machine Natural Loop Construction", true, true)
      32       53279 : INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
      33     2142871 : INITIALIZE_PASS_END(MachineLoopInfo, "machine-loops",
      34             :                 "Machine Natural Loop Construction", true, true)
      35             : 
      36             : char &llvm::MachineLoopInfoID = MachineLoopInfo::ID;
      37             : 
      38      878123 : bool MachineLoopInfo::runOnMachineFunction(MachineFunction &) {
      39      878123 :   releaseMemory();
      40      878123 :   LI.analyze(getAnalysis<MachineDominatorTree>().getBase());
      41      878123 :   return false;
      42             : }
      43             : 
      44      101231 : void MachineLoopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
      45      202462 :   AU.setPreservesAll();
      46      101231 :   AU.addRequired<MachineDominatorTree>();
      47      101231 :   MachineFunctionPass::getAnalysisUsage(AU);
      48      101231 : }
      49             : 
      50         269 : MachineBasicBlock *MachineLoop::getTopBlock() {
      51         538 :   MachineBasicBlock *TopMBB = getHeader();
      52         538 :   MachineFunction::iterator Begin = TopMBB->getParent()->begin();
      53         538 :   if (TopMBB->getIterator() != Begin) {
      54             :     MachineBasicBlock *PriorMBB = &*std::prev(TopMBB->getIterator());
      55         540 :     while (contains(PriorMBB)) {
      56           1 :       TopMBB = PriorMBB;
      57           2 :       if (TopMBB->getIterator() == Begin)
      58             :         break;
      59             :       PriorMBB = &*std::prev(TopMBB->getIterator());
      60             :     }
      61             :   }
      62         269 :   return TopMBB;
      63             : }
      64             : 
      65         163 : MachineBasicBlock *MachineLoop::getBottomBlock() {
      66         326 :   MachineBasicBlock *BotMBB = getHeader();
      67         326 :   MachineFunction::iterator End = BotMBB->getParent()->end();
      68         326 :   if (BotMBB->getIterator() != std::prev(End)) {
      69             :     MachineBasicBlock *NextMBB = &*std::next(BotMBB->getIterator());
      70         288 :     while (contains(NextMBB)) {
      71           0 :       BotMBB = NextMBB;
      72           0 :       if (BotMBB == &*std::next(BotMBB->getIterator()))
      73             :         break;
      74             :       NextMBB = &*std::next(BotMBB->getIterator());
      75             :     }
      76             :   }
      77         163 :   return BotMBB;
      78             : }
      79             : 
      80         781 : MachineBasicBlock *MachineLoop::findLoopControlBlock() {
      81         781 :   if (MachineBasicBlock *Latch = getLoopLatch()) {
      82        1560 :     if (isLoopExiting(Latch))
      83             :       return Latch;
      84             :     else
      85          26 :       return getExitingBlock();
      86             :   }
      87             :   return nullptr;
      88             : }
      89             : 
      90         973 : DebugLoc MachineLoop::getStartLoc() const {
      91             :   // Try the pre-header first.
      92         973 :   if (MachineBasicBlock *PHeadMBB = getLoopPreheader())
      93         963 :     if (const BasicBlock *PHeadBB = PHeadMBB->getBasicBlock())
      94        2946 :       if (DebugLoc DL = PHeadBB->getTerminator()->getDebugLoc())
      95        1644 :         return DL;
      96             : 
      97             :   // If we have no pre-header or there are no instructions with debug
      98             :   // info in it, try the header.
      99         302 :   if (MachineBasicBlock *HeadMBB = getHeader())
     100         151 :     if (const BasicBlock *HeadBB = HeadMBB->getBasicBlock())
     101         149 :       return HeadBB->getTerminator()->getDebugLoc();
     102             : 
     103           2 :   return DebugLoc();
     104             : }
     105             : 
     106             : MachineBasicBlock *
     107         497 : MachineLoopInfo::findLoopPreheader(MachineLoop *L,
     108             :                                    bool SpeculativePreheader) const {
     109         497 :   if (MachineBasicBlock *PB = L->getLoopPreheader())
     110             :     return PB;
     111             : 
     112           0 :   if (!SpeculativePreheader)
     113             :     return nullptr;
     114             : 
     115           0 :   MachineBasicBlock *HB = L->getHeader(), *LB = L->getLoopLatch();
     116           0 :   if (HB->pred_size() != 2 || HB->hasAddressTaken())
     117             :     return nullptr;
     118             :   // Find the predecessor of the header that is not the latch block.
     119             :   MachineBasicBlock *Preheader = nullptr;
     120           0 :   for (MachineBasicBlock *P : HB->predecessors()) {
     121           0 :     if (P == LB)
     122           0 :       continue;
     123             :     // Sanity.
     124           0 :     if (Preheader)
     125             :       return nullptr;
     126             :     Preheader = P;
     127             :   }
     128             : 
     129             :   // Check if the preheader candidate is a successor of any other loop
     130             :   // headers. We want to avoid having two loop setups in the same block.
     131           0 :   for (MachineBasicBlock *S : Preheader->successors()) {
     132           0 :     if (S == HB)
     133           0 :       continue;
     134           0 :     MachineLoop *T = getLoopFor(S);
     135           0 :     if (T && T->getHeader() == S)
     136             :       return nullptr;
     137             :   }
     138             :   return Preheader;
     139             : }
     140             : 
     141             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     142             : LLVM_DUMP_METHOD void MachineLoop::dump() const {
     143             :   print(dbgs());
     144             : }
     145             : #endif

Generated by: LCOV version 1.13