Home | History | Annotate | Download | only in CodeGen 
      1 //===--- LivePhysRegs.cpp - Live Physical Register 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 // This file implements the LivePhysRegs utility for tracking liveness of
     11 // physical registers across machine instructions in forward or backward order.
     12 // A more detailed description can be found in the corresponding header file.
     13 //
     14 //===----------------------------------------------------------------------===//
     15 
     16 #include "llvm/CodeGen/LivePhysRegs.h"
     17 #include "llvm/CodeGen/MachineInstrBundle.h"
     18 #include "llvm/Support/Debug.h"
     19 using namespace llvm;
     20 
     21 
     22 /// \brief Remove all registers from the set that get clobbered by the register
     23 /// mask.
     24 void LivePhysRegs::removeRegsInMask(const MachineOperand &MO) {
     25   SparseSet<unsigned>::iterator LRI = LiveRegs.begin();
     26   while (LRI != LiveRegs.end()) {
     27     if (MO.clobbersPhysReg(*LRI))
     28       LRI = LiveRegs.erase(LRI);
     29     else
     30       ++LRI;
     31   }
     32 }
     33 
     34 /// Simulates liveness when stepping backwards over an instruction(bundle):
     35 /// Remove Defs, add uses. This is the recommended way of calculating liveness.
     36 void LivePhysRegs::stepBackward(const MachineInstr &MI) {
     37   // Remove defined registers and regmask kills from the set.
     38   for (ConstMIBundleOperands O(&MI); O.isValid(); ++O) {
     39     if (O->isReg()) {
     40       if (!O->isDef())
     41         continue;
     42       unsigned Reg = O->getReg();
     43       if (Reg == 0)
     44         continue;
     45       removeReg(Reg);
     46     } else if (O->isRegMask())
     47       removeRegsInMask(*O);
     48   }
     49 
     50   // Add uses to the set.
     51   for (ConstMIBundleOperands O(&MI); O.isValid(); ++O) {
     52     if (!O->isReg() || !O->readsReg() || O->isUndef())
     53       continue;
     54     unsigned Reg = O->getReg();
     55     if (Reg == 0)
     56       continue;
     57     addReg(Reg);
     58   }
     59 }
     60 
     61 /// Simulates liveness when stepping forward over an instruction(bundle): Remove
     62 /// killed-uses, add defs. This is the not recommended way, because it depends
     63 /// on accurate kill flags. If possible use stepBackwards() instead of this
     64 /// function.
     65 void LivePhysRegs::stepForward(const MachineInstr &MI) {
     66   SmallVector<unsigned, 4> Defs;
     67   // Remove killed registers from the set.
     68   for (ConstMIBundleOperands O(&MI); O.isValid(); ++O) {
     69     if (O->isReg()) {
     70       unsigned Reg = O->getReg();
     71       if (Reg == 0)
     72         continue;
     73       if (O->isDef()) {
     74         if (!O->isDead())
     75           Defs.push_back(Reg);
     76       } else {
     77         if (!O->isKill())
     78           continue;
     79         assert(O->isUse());
     80         removeReg(Reg);
     81       }
     82     } else if (O->isRegMask())
     83       removeRegsInMask(*O);
     84   }
     85 
     86   // Add defs to the set.
     87   for (unsigned i = 0, e = Defs.size(); i != e; ++i)
     88     addReg(Defs[i]);
     89 }
     90 
     91 /// Prin the currently live registers to OS.
     92 void LivePhysRegs::print(raw_ostream &OS) const {
     93   OS << "Live Registers:";
     94   if (!TRI) {
     95     OS << " (uninitialized)\n";
     96     return;
     97   }
     98 
     99   if (empty()) {
    100     OS << " (empty)\n";
    101     return;
    102   }
    103 
    104   for (const_iterator I = begin(), E = end(); I != E; ++I)
    105     OS << " " << PrintReg(*I, TRI);
    106   OS << "\n";
    107 }
    108 
    109 /// Dumps the currently live registers to the debug output.
    110 void LivePhysRegs::dump() const {
    111 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
    112   dbgs() << "  " << *this;
    113 #endif
    114 }
    115