include/llvm/CodeGen/LivePhysRegs.h

   1 //===- llvm/CodeGen/LivePhysRegs.h - Live Physical Register Set -*- 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 implements the LivePhysRegs utility for tracking liveness of
  11 // physical registers. This can be used for ad-hoc liveness tracking after
  12 // register allocation. You can start with the live-ins/live-outs at the
  13 // beginning/end of a block and update the information while walking the
  14 // instructions inside the block. This implementation tracks the liveness on a
  15 // sub-register granularity.
  16 //
  17 // We assume that the high bits of a physical super-register are not preserved
  18 // unless the instruction has an implicit-use operand reading the super-
  19 // register.
  20 //
  21 // X86 Example:
  22 // %YMM0<def> = ...
  23 // %XMM0<def> = ... (Kills %XMM0, all %XMM0s sub-registers, and %YMM0)
  24 //
  25 // %YMM0<def> = ...
  26 // %XMM0<def> = ..., %YMM0<imp-use> (%YMM0 and all its sub-registers are alive)
  27 //===----------------------------------------------------------------------===//
  28
  29 #ifndef LLVM_CODEGEN_LIVEPHYSREGS_H
  30 #define LLVM_CODEGEN_LIVEPHYSREGS_H
  31
  32 #include "llvm/ADT/SparseSet.h"
  33 #include "llvm/CodeGen/MachineBasicBlock.h"
  34 #include "llvm/Target/TargetRegisterInfo.h"
  35 #include <cassert>
  36
  37 namespace llvm {
  38
  39 class MachineInstr;
  40
  41 /// \brief A set of live physical registers with functions to track liveness
  42 /// when walking backward/forward through a basic block.
  43 class LivePhysRegs {
  44   const TargetRegisterInfo *TRI;
  45   SparseSet<unsigned> LiveRegs;
  46
  47   LivePhysRegs(const LivePhysRegs&) = delete;
  48   LivePhysRegs &operator=(const LivePhysRegs&) = delete;
  49 public:
  50   /// \brief Constructs a new empty LivePhysRegs set.
  51   LivePhysRegs() : TRI(nullptr), LiveRegs() {}
  52
  53   /// \brief Constructs and initialize an empty LivePhysRegs set.
  54   LivePhysRegs(const TargetRegisterInfo *TRI) : TRI(TRI) {
  55     assert(TRI && "Invalid TargetRegisterInfo pointer.");
  56     LiveRegs.setUniverse(TRI->getNumRegs());
  57   }
  58
  59   /// \brief Clear and initialize the LivePhysRegs set.
  60   void init(const TargetRegisterInfo *TRI) {
  61     assert(TRI && "Invalid TargetRegisterInfo pointer.");
  62     this->TRI = TRI;
  63     LiveRegs.clear();
  64     LiveRegs.setUniverse(TRI->getNumRegs());
  65   }
  66
  67   /// \brief Clears the LivePhysRegs set.
  68   void clear() { LiveRegs.clear(); }
  69
  70   /// \brief Returns true if the set is empty.
  71   bool empty() const { return LiveRegs.empty(); }
  72
  73   /// \brief Adds a physical register and all its sub-registers to the set.
  74   void addReg(unsigned Reg) {
  75     assert(TRI && "LivePhysRegs is not initialized.");
  76     assert(Reg <= TRI->getNumRegs() && "Expected a physical register.");
  77     for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true);
  78          SubRegs.isValid(); ++SubRegs)
  79       LiveRegs.insert(*SubRegs);
  80   }
  81
  82   /// \brief Removes a physical register, all its sub-registers, and all its
  83   /// super-registers from the set.
  84   void removeReg(unsigned Reg) {
  85     assert(TRI && "LivePhysRegs is not initialized.");
  86     assert(Reg <= TRI->getNumRegs() && "Expected a physical register.");
  87     for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true);
  88          SubRegs.isValid(); ++SubRegs)
  89       LiveRegs.erase(*SubRegs);
  90     for (MCSuperRegIterator SuperRegs(Reg, TRI, /*IncludeSelf=*/false);
  91          SuperRegs.isValid(); ++SuperRegs)
  92       LiveRegs.erase(*SuperRegs);
  93   }
  94
  95   /// \brief Removes physical registers clobbered by the regmask operand @p MO.
  96   void removeRegsInMask(const MachineOperand &MO,
  97         SmallVectorImpl<std::pair<unsigned, const MachineOperand*>> *Clobbers);
  98
  99   /// \brief Returns true if register @p Reg is contained in the set. This also
 100   /// works if only the super register of @p Reg has been defined, because we
 101   /// always add also all sub-registers to the set.
 102   bool contains(unsigned Reg) const { return LiveRegs.count(Reg); }
 103
 104   /// \brief Simulates liveness when stepping backwards over an
 105   /// instruction(bundle): Remove Defs, add uses. This is the recommended way of
 106   /// calculating liveness.
 107   void stepBackward(const MachineInstr &MI);
 108
 109   /// \brief Simulates liveness when stepping forward over an
 110   /// instruction(bundle): Remove killed-uses, add defs. This is the not
 111   /// recommended way, because it depends on accurate kill flags. If possible
 112   /// use stepBackward() instead of this function.
 113   /// The clobbers set will be the list of registers either defined or clobbered
 114   /// by a regmask.  The operand will identify whether this is a regmask or
 115   /// register operand.
 116   void stepForward(const MachineInstr &MI,
 117         SmallVectorImpl<std::pair<unsigned, const MachineOperand*>> &Clobbers);
 118
 119   /// \brief Adds all live-in registers of basic block @p MBB; After prologue/
 120   /// epilogue insertion \p AddPristines should be set to true to insert the
 121   /// pristine registers.
 122   void addLiveIns(const MachineBasicBlock *MBB, bool AddPristines = false);
 123
 124   /// \brief Adds all live-out registers of basic block @p MBB; After prologue/
 125   /// epilogue insertion \p AddPristinesAndCSRs should be set to true.
 126   void addLiveOuts(const MachineBasicBlock *MBB,
 127                    bool AddPristinesAndCSRs = false);
 128
 129   typedef SparseSet<unsigned>::const_iterator const_iterator;
 130   const_iterator begin() const { return LiveRegs.begin(); }
 131   const_iterator end() const { return LiveRegs.end(); }
 132
 133   /// \brief Prints the currently live registers to @p OS.
 134   void print(raw_ostream &OS) const;
 135
 136   /// \brief Dumps the currently live registers to the debug output.
 137   void dump() const;
 138 };
 139
 140 inline raw_ostream &operator<<(raw_ostream &OS, const LivePhysRegs& LR) {
 141   LR.print(OS);
 142   return OS;
 143 }
 144
 145 } // namespace llvm
 146
 147 #endif