LLVM API Documentation
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