include/llvm/CodeGen/RegisterScavenging.h

   1 //===-- RegisterScavenging.h - Machine register scavenging ------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the Evan Cheng and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the machine register scavenger class. It can provide
  11 // information such as unused register at any point in a machine basic block.
  12 // It also provides a mechanism to make registers availbale by evicting them
  13 // to spill slots.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_CODEGEN_REGISTER_SCAVENGING_H
  18 #define LLVM_CODEGEN_REGISTER_SCAVENGING_H
  19
  20 #include "llvm/CodeGen/MachineBasicBlock.h"
  21 #include "llvm/ADT/BitVector.h"
  22
  23 namespace llvm {
  24
  25 class MRegisterInfo;
  26 class TargetInstrInfo;
  27 class TargetRegisterClass;
  28
  29 class RegScavenger {
  30   MachineBasicBlock *MBB;
  31   MachineBasicBlock::iterator MBBI;
  32   unsigned NumPhysRegs;
  33
  34   /// Tracking - True if RegScavenger is currently tracking the liveness of
  35   /// registers.
  36   bool Tracking;
  37
  38   /// ScavengingFrameIndex - Special spill slot used for scavenging a register
  39   /// post register allocation.
  40   int ScavengingFrameIndex;
  41
  42   /// ScavengedReg - If none zero, the specific register is currently being
  43   /// scavenged. That is, it is spilled to the special scavenging stack slot.
  44   unsigned ScavengedReg;
  45
  46   /// ScavengedRC - Register class of the scavenged register.
  47   ///
  48   const TargetRegisterClass *ScavengedRC;
  49
  50   /// RegStates - The current state of all the physical registers immediately
  51   /// before MBBI. One bit per physical register. If bit is set that means it's
  52   /// available, unset means the register is currently being used.
  53   BitVector RegStates;
  54
  55 public:
  56   RegScavenger()
  57     : MBB(NULL), NumPhysRegs(0), Tracking(false),
  58       ScavengingFrameIndex(-1), ScavengedReg(0), ScavengedRC(NULL) {};
  59
  60   RegScavenger(MachineBasicBlock *mbb)
  61     : MBB(mbb), NumPhysRegs(0), Tracking(false),
  62       ScavengingFrameIndex(-1), ScavengedReg(0), ScavengedRC(NULL) {};
  63
  64   /// enterBasicBlock - Start tracking liveness from the begin of the specific
  65   /// basic block.
  66   void enterBasicBlock(MachineBasicBlock *mbb);
  67
  68   /// forward / backward - Move the internal MBB iterator and update register
  69   /// states.
  70   void forward();
  71   void backward();
  72
  73   /// forward / backward - Move the internal MBB iterator and update register
  74   /// states until it has processed the specific iterator.
  75   void forward(MachineBasicBlock::iterator I) {
  76     while (MBBI != I) forward();
  77   }
  78   void backward(MachineBasicBlock::iterator I) {
  79     while (MBBI != I) backward();
  80   }
  81
  82   /// skipTo - Move the internal MBB iterator but do not update register states.
  83   ///
  84   void skipTo(MachineBasicBlock::iterator I) { MBBI = I; }
  85
  86   /// isReserved - Returns true if a register is reserved. It is never "unused".
  87   bool isReserved(unsigned Reg) const { return ReservedRegs[Reg]; }
  88
  89   /// isUsed / isUsed - Test if a register is currently being used.
  90   ///
  91   bool isUsed(unsigned Reg) const   { return !RegStates[Reg]; }
  92   bool isUnused(unsigned Reg) const { return RegStates[Reg]; }
  93
  94   /// getRegsUsed - return all registers currently in use in used.
  95   void getRegsUsed(BitVector &used, bool includeReserved);
  96
  97   /// setUsed / setUnused - Mark the state of one or a number of registers.
  98   ///
  99   void setUsed(unsigned Reg)     { RegStates.reset(Reg); }
 100   void setUsed(BitVector Regs)   { RegStates &= ~Regs; }
 101   void setUnused(unsigned Reg)   { RegStates.set(Reg); }
 102   void setUnused(BitVector Regs) { RegStates |= Regs; }
 103
 104   /// FindUnusedReg - Find a unused register of the specified register class
 105   /// from the specified set of registers. It return 0 is none is found.
 106   unsigned FindUnusedReg(const TargetRegisterClass *RegClass,
 107                          const BitVector &Candidates) const;
 108
 109   /// FindUnusedReg - Find a unused register of the specified register class.
 110   /// Exclude callee saved registers if directed. It return 0 is none is found.
 111   unsigned FindUnusedReg(const TargetRegisterClass *RegClass,
 112                          bool ExCalleeSaved = false) const;
 113
 114   /// setScavengingFrameIndex / getScavengingFrameIndex - accessor and setter of
 115   /// ScavengingFrameIndex.
 116   void setScavengingFrameIndex(int FI) { ScavengingFrameIndex = FI; }
 117   int getScavengingFrameIndex() const { return ScavengingFrameIndex; }
 118
 119   /// scavengeRegister - Make a register of the specific register class
 120   /// available and do the appropriate bookkeeping. Returns the scavenged
 121   /// register.
 122   unsigned scavengeRegister(const TargetRegisterClass *RegClass,
 123                             MachineBasicBlock::iterator I);
 124   unsigned scavengeRegister(const TargetRegisterClass *RegClass) {
 125     return scavengeRegister(RegClass, MBBI);
 126   }
 127
 128 private:
 129   const MRegisterInfo *RegInfo;
 130   const TargetInstrInfo *TII;
 131
 132   /// CalleeSavedrRegs - A bitvector of callee saved registers for the target.
 133   ///
 134   BitVector CalleeSavedRegs;
 135
 136   /// ReservedRegs - A bitvector of reserved registers.
 137   ///
 138   BitVector ReservedRegs;
 139
 140   /// restoreScavengedReg - Restore scavenged by loading it back from the
 141   /// emergency spill slot. Mark it used.
 142   void restoreScavengedReg();
 143 };
 144
 145 } // End llvm namespace
 146
 147 #endif