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 TargetRegisterClass;
  26
  27 class RegScavenger {
  28   MachineBasicBlock *MBB;
  29   MachineBasicBlock::iterator MBBI;
  30   unsigned NumPhysRegs;
  31
  32   /// Initialized - All states are initialized and ready to go!
  33   bool Initialized;
  34
  35   /// RegStates - The current state of all the physical registers immediately
  36   /// before MBBI. One bit per physical register. If bit is set that means it's
  37   /// available, unset means the register is currently being used.
  38   BitVector RegStates;
  39
  40 public:
  41   RegScavenger()
  42     : MBB(NULL), Initialized(false) {};
  43
  44   RegScavenger(MachineBasicBlock *mbb)
  45     : MBB(mbb), Initialized(false) {};
  46
  47   /// Init - Initialize the states.
  48   ///
  49   void init();
  50
  51   /// Reset - Discard previous states and re-initialize the states given for
  52   /// the specific basic block.
  53   void reset(MachineBasicBlock *mbb) {
  54     MBB = mbb;
  55     clear();
  56     init();
  57   }
  58
  59   /// forward / backward - Move the internal MBB iterator and update register
  60   /// states.
  61   void forward();
  62   void backward();
  63
  64   /// forward / backward - Move the internal MBB iterator and update register
  65   /// states until it has reached but not processed the specific iterator.
  66   void forward(MachineBasicBlock::iterator I) {
  67     while (MBBI != I) forward();
  68   }
  69   void backward(MachineBasicBlock::iterator I) {
  70     while (MBBI != I) backward();
  71   }
  72
  73   /// isReserved - Returns true if a register is reserved. It is never "unused".
  74   bool isReserved(unsigned Reg) const { return ReservedRegs[Reg]; }
  75
  76   /// isUsed / isUsed - Test if a register is currently being used.
  77   ///
  78   bool isUsed(unsigned Reg) const   { return !RegStates[Reg]; }
  79   bool isUnused(unsigned Reg) const { return RegStates[Reg]; }
  80
  81   /// setUsed / setUnused - Mark the state of one or a number of registers.
  82   ///
  83   void setUsed(unsigned Reg)     { RegStates.reset(Reg); }
  84   void setUsed(BitVector Regs)   { RegStates &= ~Regs; }
  85   void setUnused(unsigned Reg)   { RegStates.set(Reg); }
  86   void setUnused(BitVector Regs) { RegStates |= Regs; }
  87
  88   /// FindUnusedReg - Find a unused register of the specified register class.
  89   /// Exclude callee saved registers if directed. It return 0 is none is found.
  90   unsigned FindUnusedReg(const TargetRegisterClass *RegClass,
  91                          bool ExCalleeSaved = false) const;
  92
  93 private:
  94   /// clear - Clear states.
  95   ///
  96   void clear();
  97
  98   /// CalleeSavedrRegs - A bitvector of callee saved registers for the target.
  99   ///
 100   BitVector CalleeSavedRegs;
 101
 102   /// ReservedRegs - A bitvector of reserved registers.
 103   ///
 104   BitVector ReservedRegs;
 105 };
 106
 107 } // End llvm namespace
 108
 109 #endif