class RegScavenger {
MachineBasicBlock *MBB;
MachineBasicBlock::iterator MBBI;
- bool MBBIInited;
unsigned NumPhysRegs;
+ /// Initialized - All states are initialized and ready to go!
+ bool Initialized;
+
/// RegStates - The current state of all the physical registers immediately
/// before MBBI. One bit per physical register. If bit is set that means it's
/// available, unset means the register is currently being used.
BitVector RegStates;
public:
- RegScavenger(MachineBasicBlock *mbb);
+ RegScavenger()
+ : MBB(NULL), Initialized(false) {};
+
+ RegScavenger(MachineBasicBlock *mbb)
+ : MBB(mbb), Initialized(false) {};
+
+ /// Init - Initialize the states.
+ ///
+ void init();
+
+ /// Reset - Discard previous states and re-initialize the states given for
+ /// the specific basic block.
+ void reset(MachineBasicBlock *mbb) {
+ MBB = mbb;
+ clear();
+ init();
+ }
/// forward / backward - Move the internal MBB iterator and update register
/// states.
/// forward / backward - Move the internal MBB iterator and update register
/// states until it has reached but not processed the specific iterator.
- void forward(MachineBasicBlock::iterator I);
- void backward(MachineBasicBlock::iterator I);
+ void forward(MachineBasicBlock::iterator I) {
+ while (MBBI != I) forward();
+ }
+ void backward(MachineBasicBlock::iterator I) {
+ while (MBBI != I) backward();
+ }
/// isReserved - Returns true if a register is reserved. It is never "unused".
bool isReserved(unsigned Reg) const { return ReservedRegs[Reg]; }
bool ExCalleeSaved = false) const;
private:
+ /// clear - Clear states.
+ ///
+ void clear();
+
/// CalleeSavedrRegs - A bitvector of callee saved registers for the target.
+ ///
BitVector CalleeSavedRegs;
/// ReservedRegs - A bitvector of reserved registers.
+ ///
BitVector ReservedRegs;
};
#include "llvm/ADT/STLExtras.h"
using namespace llvm;
-RegScavenger::RegScavenger(MachineBasicBlock *mbb)
- : MBB(mbb), MBBIInited(false) {
+void RegScavenger::init() {
const MachineFunction &MF = *MBB->getParent();
const TargetMachine &TM = MF.getTarget();
const MRegisterInfo *RegInfo = TM.getRegisterInfo();
+ MBBI = MBB->begin();
NumPhysRegs = RegInfo->getNumRegs();
RegStates.resize(NumPhysRegs, true);
for (MachineBasicBlock::const_livein_iterator I = MBB->livein_begin(),
E = MBB->livein_end(); I != E; ++I)
setUsed(*I);
+
+ Initialized = true;
}
void RegScavenger::forward() {
assert(MBBI != MBB->end() && "Already at the end of the basic block!");
// Move ptr forward.
- if (!MBBIInited) {
- MBBI = MBB->begin();
- MBBIInited = true;
- } else
+ if (!Initialized)
+ init();
+ else
MBBI = next(MBBI);
MachineInstr *MI = MBBI;
setUsed(ChangedRegs);
}
-void RegScavenger::forward(MachineBasicBlock::iterator I) {
- while (MBBI != I)
- forward();
-}
-
-void RegScavenger::backward(MachineBasicBlock::iterator I) {
- while (MBBI != I)
- backward();
-}
-
/// CreateRegClassMask - Set the bits that represent the registers in the
/// TargetRegisterClass.
static void CreateRegClassMask(const TargetRegisterClass *RC, BitVector &Mask) {
int Reg = RegStatesCopy.find_first();
return (Reg == -1) ? 0 : Reg;
}
+
+void RegScavenger::clear() {
+ if (MBB) {
+ MBBI = MBB->end();
+ MBB = NULL;
+ }
+
+ NumPhysRegs = 0;
+ Initialized = false;
+ RegStates.clear();
+}