LCOV - code coverage report
Current view: top level - lib/CodeGen - LiveRegUnits.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 73 78 93.6 %
Date: 2018-07-13 00:08:38 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- LiveRegUnits.cpp - Register Unit Set -------------------------------===//
       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             : /// \file This file imlements the LiveRegUnits set.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/CodeGen/LiveRegUnits.h"
      15             : 
      16             : #include "llvm/CodeGen/MachineBasicBlock.h"
      17             : #include "llvm/CodeGen/MachineFrameInfo.h"
      18             : #include "llvm/CodeGen/MachineFunction.h"
      19             : #include "llvm/CodeGen/MachineInstrBundle.h"
      20             : #include "llvm/CodeGen/MachineOperand.h"
      21             : #include "llvm/CodeGen/MachineRegisterInfo.h"
      22             : #include "llvm/CodeGen/TargetRegisterInfo.h"
      23             : #include "llvm/MC/MCRegisterInfo.h"
      24             : 
      25             : using namespace llvm;
      26             : 
      27        1593 : void LiveRegUnits::removeRegsNotPreserved(const uint32_t *RegMask) {
      28      168897 :   for (unsigned U = 0, E = TRI->getNumRegUnits(); U != E; ++U) {
      29      503581 :     for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
      30      168973 :       if (MachineOperand::clobbersPhysReg(RegMask, *RootReg))
      31             :         Units.reset(U);
      32             :     }
      33             :   }
      34        1593 : }
      35             : 
      36        1048 : void LiveRegUnits::addRegsInMask(const uint32_t *RegMask) {
      37      120468 :   for (unsigned U = 0, E = TRI->getNumRegUnits(); U != E; ++U) {
      38      358288 :     for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
      39      119448 :       if (MachineOperand::clobbersPhysReg(RegMask, *RootReg))
      40             :         Units.set(U);
      41             :     }
      42             :   }
      43        1048 : }
      44             : 
      45       43291 : void LiveRegUnits::stepBackward(const MachineInstr &MI) {
      46             :   // Remove defined registers and regmask kills from the set.
      47      206506 :   for (ConstMIBundleOperands O(MI); O.isValid(); ++O) {
      48      163215 :     if (O->isReg()) {
      49      106170 :       if (!O->isDef() || O->isDebug())
      50       69026 :         continue;
      51       37144 :       unsigned Reg = O->getReg();
      52       37144 :       if (!TargetRegisterInfo::isPhysicalRegister(Reg))
      53           0 :         continue;
      54       37144 :       removeReg(Reg);
      55       57045 :     } else if (O->isRegMask())
      56        1593 :       removeRegsNotPreserved(O->getRegMask());
      57             :   }
      58             : 
      59             :   // Add uses to the set.
      60      206506 :   for (ConstMIBundleOperands O(MI); O.isValid(); ++O) {
      61      326456 :     if (!O->isReg() || !O->readsReg() || O->isDebug())
      62       94578 :       continue;
      63       68637 :     unsigned Reg = O->getReg();
      64       89697 :     if (!TargetRegisterInfo::isPhysicalRegister(Reg))
      65       21060 :       continue;
      66       47577 :     addReg(Reg);
      67             :   }
      68       43291 : }
      69             : 
      70        5022 : void LiveRegUnits::accumulate(const MachineInstr &MI) {
      71             :   // Add defs, uses and regmask clobbers to the set.
      72       25176 :   for (ConstMIBundleOperands O(MI); O.isValid(); ++O) {
      73       20154 :     if (O->isReg()) {
      74       13968 :       unsigned Reg = O->getReg();
      75       13968 :       if (!TargetRegisterInfo::isPhysicalRegister(Reg))
      76        7578 :         continue;
      77        6429 :       if (!O->isDef() && !O->readsReg())
      78          39 :         continue;
      79        6351 :       addReg(Reg);
      80        6186 :     } else if (O->isRegMask())
      81          18 :       addRegsInMask(O->getRegMask());
      82             :   }
      83        5022 : }
      84             : 
      85             : /// Add live-in registers of basic block \p MBB to \p LiveUnits.
      86       14462 : static void addBlockLiveIns(LiveRegUnits &LiveUnits,
      87             :                             const MachineBasicBlock &MBB) {
      88       65264 :   for (const auto &LI : MBB.liveins())
      89       50802 :     LiveUnits.addRegMasked(LI.PhysReg, LI.LaneMask);
      90       14462 : }
      91             : 
      92             : /// Adds all callee saved registers to \p LiveUnits.
      93        2256 : static void addCalleeSavedRegs(LiveRegUnits &LiveUnits,
      94             :                                const MachineFunction &MF) {
      95        2256 :   const MachineRegisterInfo &MRI = MF.getRegInfo();
      96       59778 :   for (const MCPhysReg *CSR = MRI.getCalleeSavedRegs(); CSR && *CSR; ++CSR)
      97       57522 :     LiveUnits.addReg(*CSR);
      98        2256 : }
      99             : 
     100       13767 : void LiveRegUnits::addPristines(const MachineFunction &MF) {
     101       13767 :   const MachineFrameInfo &MFI = MF.getFrameInfo();
     102       13767 :   if (!MFI.isCalleeSavedInfoValid())
     103       13767 :     return;
     104             :   /// This function will usually be called on an empty object, handle this
     105             :   /// as a special case.
     106        1506 :   if (empty()) {
     107             :     /// Add all callee saved regs, then remove the ones that are saved and
     108             :     /// restored.
     109        1506 :     addCalleeSavedRegs(*this, MF);
     110             :     /// Remove the ones that are not saved/restored; they are pristine.
     111        1506 :     for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
     112        8616 :       removeReg(Info.getReg());
     113             :     return;
     114             :   }
     115             :   /// If a callee-saved register that is not pristine is already present
     116             :   /// in the set, we should make sure that it stays in it. Precompute the
     117             :   /// set of pristine registers in a separate object.
     118             :   /// Add all callee saved regs, then remove the ones that are saved+restored.
     119           0 :   LiveRegUnits Pristine(*TRI);
     120           0 :   addCalleeSavedRegs(Pristine, MF);
     121             :   /// Remove the ones that are not saved/restored; they are pristine.
     122           0 :   for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
     123           0 :     Pristine.removeReg(Info.getReg());
     124             :   addUnits(Pristine.getBitVector());
     125             : }
     126             : 
     127        2025 : void LiveRegUnits::addLiveOuts(const MachineBasicBlock &MBB) {
     128        2025 :   const MachineFunction &MF = *MBB.getParent();
     129        2025 :   if (!MBB.succ_empty()) {
     130        1119 :     addPristines(MF);
     131             :     // To get the live-outs we simply merge the live-ins of all successors.
     132        2933 :     for (const MachineBasicBlock *Succ : MBB.successors())
     133        1814 :       addBlockLiveIns(*this, *Succ);
     134         906 :   } else if (MBB.isReturnBlock()) {
     135             :     // For the return block: Add all callee saved registers.
     136         878 :     const MachineFrameInfo &MFI = MF.getFrameInfo();
     137         878 :     if (MFI.isCalleeSavedInfoValid())
     138         750 :       addCalleeSavedRegs(*this, MF);
     139             :   }
     140        2025 : }
     141             : 
     142       12648 : void LiveRegUnits::addLiveIns(const MachineBasicBlock &MBB) {
     143       12648 :   const MachineFunction &MF = *MBB.getParent();
     144       12648 :   addPristines(MF);
     145       12648 :   addBlockLiveIns(*this, MBB);
     146       12648 : }

Generated by: LCOV version 1.13