LLVM API Documentation

RegisterScavenging.h

Go to the documentation of this file.
00001 //===-- RegisterScavenging.h - Machine register scavenging ------*- C++ -*-===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file declares the machine register scavenger class. It can provide
00011 // information such as unused register at any point in a machine basic block.
00012 // It also provides a mechanism to make registers availbale by evicting them
00013 // to spill slots.
00014 //
00015 //===----------------------------------------------------------------------===//
00016 
00017 #ifndef LLVM_CODEGEN_REGISTER_SCAVENGING_H
00018 #define LLVM_CODEGEN_REGISTER_SCAVENGING_H
00019 
00020 #include "llvm/CodeGen/MachineBasicBlock.h"
00021 #include "llvm/ADT/BitVector.h"
00022 
00023 namespace llvm {
00024 
00025 class MachineRegisterInfo;
00026 class TargetRegisterInfo;
00027 class TargetInstrInfo;
00028 class TargetRegisterClass;
00029 
00030 class RegScavenger {
00031   const TargetRegisterInfo *TRI;
00032   const TargetInstrInfo *TII;
00033   MachineRegisterInfo* MRI;
00034   MachineBasicBlock *MBB;
00035   MachineBasicBlock::iterator MBBI;
00036   unsigned NumPhysRegs;
00037 
00038   /// Tracking - True if RegScavenger is currently tracking the liveness of 
00039   /// registers.
00040   bool Tracking;
00041 
00042   /// ScavengingFrameIndex - Special spill slot used for scavenging a register
00043   /// post register allocation.
00044   int ScavengingFrameIndex;
00045 
00046   /// ScavengedReg - If none zero, the specific register is currently being
00047   /// scavenged. That is, it is spilled to the special scavenging stack slot.
00048   unsigned ScavengedReg;
00049 
00050   /// ScavengedRC - Register class of the scavenged register.
00051   ///
00052   const TargetRegisterClass *ScavengedRC;
00053 
00054   /// ScavengeRestore - Instruction that restores the scavenged register from
00055   /// stack.
00056   const MachineInstr *ScavengeRestore;
00057 
00058   /// CalleeSavedrRegs - A bitvector of callee saved registers for the target.
00059   ///
00060   BitVector CalleeSavedRegs;
00061 
00062   /// ReservedRegs - A bitvector of reserved registers.
00063   ///
00064   BitVector ReservedRegs;
00065 
00066   /// RegsAvailable - The current state of all the physical registers immediately
00067   /// before MBBI. One bit per physical register. If bit is set that means it's
00068   /// available, unset means the register is currently being used.
00069   BitVector RegsAvailable;
00070 
00071 public:
00072   RegScavenger()
00073     : MBB(NULL), NumPhysRegs(0), Tracking(false),
00074       ScavengingFrameIndex(-1), ScavengedReg(0), ScavengedRC(NULL) {}
00075 
00076   /// enterBasicBlock - Start tracking liveness from the begin of the specific
00077   /// basic block.
00078   void enterBasicBlock(MachineBasicBlock *mbb);
00079 
00080   /// initRegState - allow resetting register state info for multiple
00081   /// passes over/within the same function.
00082   void initRegState();
00083 
00084   /// forward - Move the internal MBB iterator and update register states.
00085   void forward();
00086 
00087   /// forward - Move the internal MBB iterator and update register states until
00088   /// it has processed the specific iterator.
00089   void forward(MachineBasicBlock::iterator I) {
00090     if (!Tracking && MBB->begin() != I) forward();
00091     while (MBBI != I) forward();
00092   }
00093 
00094   /// skipTo - Move the internal MBB iterator but do not update register states.
00095   ///
00096   void skipTo(MachineBasicBlock::iterator I) { MBBI = I; }
00097 
00098   /// getRegsUsed - return all registers currently in use in used.
00099   void getRegsUsed(BitVector &used, bool includeReserved);
00100 
00101   /// FindUnusedReg - Find a unused register of the specified register class.
00102   /// Return 0 if none is found.
00103   unsigned FindUnusedReg(const TargetRegisterClass *RegClass) const;
00104 
00105   /// setScavengingFrameIndex / getScavengingFrameIndex - accessor and setter of
00106   /// ScavengingFrameIndex.
00107   void setScavengingFrameIndex(int FI) { ScavengingFrameIndex = FI; }
00108   int getScavengingFrameIndex() const { return ScavengingFrameIndex; }
00109 
00110   /// scavengeRegister - Make a register of the specific register class
00111   /// available and do the appropriate bookkeeping. SPAdj is the stack
00112   /// adjustment due to call frame, it's passed along to eliminateFrameIndex().
00113   /// Returns the scavenged register.
00114   unsigned scavengeRegister(const TargetRegisterClass *RegClass,
00115                             MachineBasicBlock::iterator I, int SPAdj);
00116   unsigned scavengeRegister(const TargetRegisterClass *RegClass, int SPAdj) {
00117     return scavengeRegister(RegClass, MBBI, SPAdj);
00118   }
00119 
00120 private:
00121   /// isReserved - Returns true if a register is reserved. It is never "unused".
00122   bool isReserved(unsigned Reg) const { return ReservedRegs.test(Reg); }
00123 
00124   /// isUsed / isUsed - Test if a register is currently being used.
00125   ///
00126   bool isUsed(unsigned Reg) const   { return !RegsAvailable.test(Reg); }
00127   bool isUnused(unsigned Reg) const { return RegsAvailable.test(Reg); }
00128 
00129   /// isAliasUsed - Is Reg or an alias currently in use?
00130   bool isAliasUsed(unsigned Reg) const;
00131 
00132   /// setUsed / setUnused - Mark the state of one or a number of registers.
00133   ///
00134   void setUsed(unsigned Reg);
00135   void setUsed(BitVector &Regs) {
00136     RegsAvailable &= ~Regs;
00137   }
00138   void setUnused(BitVector &Regs) {
00139     RegsAvailable |= Regs;
00140   }
00141 
00142   /// Add Reg and all its sub-registers to BV.
00143   void addRegWithSubRegs(BitVector &BV, unsigned Reg);
00144 
00145   /// Add Reg and its aliases to BV.
00146   void addRegWithAliases(BitVector &BV, unsigned Reg);
00147 
00148   unsigned findSurvivorReg(MachineBasicBlock::iterator MI,
00149                            BitVector &Candidates,
00150                            unsigned InstrLimit,
00151                            MachineBasicBlock::iterator &UseMI);
00152 
00153 };
00154 
00155 } // End llvm namespace
00156 
00157 #endif