unsigned VirtReg, unsigned PhysReg);
/// spillPhysReg - This method spills the specified physical register into
- /// the virtual register slot associated with it.
+ /// the virtual register slot associated with it. If OnlyVirtRegs is set to
+ /// true, then the request is ignored if the physical register does not
+ /// contain a virtual register.
///
void spillPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I,
- unsigned PhysReg);
+ unsigned PhysReg, bool OnlyVirtRegs = false);
/// assignVirtToPhysReg - This method updates local state so that we know
/// that PhysReg is the proper container for VirtReg now. The physical
///
void RA::spillVirtReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I,
unsigned VirtReg, unsigned PhysReg) {
-
- DEBUG(std::cerr << " Spilling register " << RegInfo->getName(PhysReg));
- if (VirtReg == 0) {
- DEBUG(std::cerr << " which corresponds to no vreg, "
- << "must be spurious physreg: ignoring (WARNING)\n");
- } else {
- // FIXME: move this into the conditional??
+ if (!VirtReg && DisableKill) return;
+ assert(VirtReg && "Spilling a physical register is illegal!"
+ " Must not have appropriate kill for the register or use exists beyond"
+ " the intended one.");
+ DEBUG(std::cerr << " Spilling register " << RegInfo->getName(PhysReg);
+ std::cerr << " containing %reg" << VirtReg;
+ if (!isVirtRegModified(VirtReg))
+ std::cerr << " which has not been modified, so no store necessary!");
+
+ // Otherwise, there is a virtual register corresponding to this physical
+ // register. We only need to spill it into its stack slot if it has been
+ // modified.
+ if (isVirtRegModified(VirtReg)) {
const TargetRegisterClass *RC = MF->getSSARegMap()->getRegClass(VirtReg);
int FrameIndex = getStackSpaceFor(VirtReg, RC);
-
- DEBUG(std::cerr << " containing %reg" << VirtReg;
- if (!isVirtRegModified(VirtReg))
- std::cerr << " which has not been modified, so no store necessary!");
-
- // Otherwise, there is a virtual register corresponding to this physical
- // register. We only need to spill it into its stack slot if it has been
- // modified.
- if (isVirtRegModified(VirtReg)) {
- DEBUG(std::cerr << " to stack slot #" << FrameIndex);
- RegInfo->storeRegToStackSlot(MBB, I, PhysReg, FrameIndex, RC);
- ++NumSpilled; // Update statistics
- }
- Virt2PhysRegMap.erase(VirtReg); // VirtReg no longer available
+ DEBUG(std::cerr << " to stack slot #" << FrameIndex);
+ RegInfo->storeRegToStackSlot(MBB, I, PhysReg, FrameIndex, RC);
+ ++NumSpilled; // Update statistics
}
+ Virt2PhysRegMap.erase(VirtReg); // VirtReg no longer available
DEBUG(std::cerr << "\n");
removePhysReg(PhysReg);
/// spillPhysReg - This method spills the specified physical register into the
-/// virtual register slot associated with it.
+/// virtual register slot associated with it. If OnlyVirtRegs is set to true,
+/// then the request is ignored if the physical register does not contain a
+/// virtual register.
///
void RA::spillPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I,
- unsigned PhysReg) {
+ unsigned PhysReg, bool OnlyVirtRegs) {
std::map<unsigned, unsigned>::iterator PI = PhysRegsUsed.find(PhysReg);
if (PI != PhysRegsUsed.end()) { // Only spill it if it's used!
- spillVirtReg(MBB, I, PI->second, PhysReg);
+ if (PI->second || !OnlyVirtRegs)
+ spillVirtReg(MBB, I, PI->second, PhysReg);
} else if (const unsigned *AliasSet = RegInfo->getAliasSet(PhysReg)) {
// If the selected register aliases any other registers, we must make
// sure that one of the aliases isn't alive...
for (unsigned i = 0; AliasSet[i]; ++i) {
PI = PhysRegsUsed.find(AliasSet[i]);
if (PI != PhysRegsUsed.end()) // Spill aliased register...
- spillVirtReg(MBB, I, PI->second, AliasSet[i]);
+ if (PI->second || !OnlyVirtRegs)
+ spillVirtReg(MBB, I, PI->second, AliasSet[i]);
}
}
}
"Couldn't find a register of the appropriate class!");
unsigned R = PhysRegsUseOrder[i];
- // If the current register is compatible, use it.
- if (RegInfo->getRegClass(R) == RC) {
- PhysReg = R;
- break;
- } else {
- // If one of the registers aliased to the current register is
- // compatible, use it.
- if (const unsigned *AliasSet = RegInfo->getAliasSet(R))
- for (unsigned a = 0; AliasSet[a]; ++a)
- if (RegInfo->getRegClass(AliasSet[a]) == RC) {
- PhysReg = AliasSet[a]; // Take an aliased register
- break;
- }
+
+ // We can only use this register if it holds a virtual register (ie, it
+ // can be spilled). Do not use it if it is an explicitly allocated
+ // physical register!
+ assert(PhysRegsUsed.count(R) &&
+ "PhysReg in PhysRegsUseOrder, but is not allocated?");
+ if (PhysRegsUsed[R]) {
+ // If the current register is compatible, use it.
+ if (RegInfo->getRegClass(R) == RC) {
+ PhysReg = R;
+ break;
+ } else {
+ // If one of the registers aliased to the current register is
+ // compatible, use it.
+ if (const unsigned *AliasSet = RegInfo->getAliasSet(R))
+ for (unsigned a = 0; AliasSet[a]; ++a)
+ if (RegInfo->getRegClass(AliasSet[a]) == RC) {
+ PhysReg = AliasSet[a]; // Take an aliased register
+ break;
+ }
+ }
}
}
for (unsigned i = 0; ImplicitUses[i]; ++i)
MarkPhysRegRecentlyUsed(ImplicitUses[i]);
- // Get the used operands into registers. This has the potiential to spill
+ // Get the used operands into registers. This has the potential to spill
// incoming values if we are out of registers. Note that we completely
// ignore physical register uses here. We assume that if an explicit
// physical register is referenced by the instruction, that it is guaranteed
if (PhysReg) {
DEBUG(std::cerr << " Last use of " << RegInfo->getName(PhysReg)
<< "[%reg" << VirtReg <<"], removing it from live set\n");
- // If the physical register was used, but there was no definition of
- // the physical register (we are reading garbage), Live Variables will
- // tell us that this is the last use of the register even though we
- // don't know of anything in the register. No need to remove it.
- if (VirtReg != PhysReg || PhysRegsUsed.count(PhysReg))
- removePhysReg(PhysReg);
+ removePhysReg(PhysReg);
}
}
}
MI->getOperand(i).opIsDefAndUse()) &&
MI->getOperand(i).isPhysicalRegister()) {
unsigned Reg = MI->getOperand(i).getAllocatedRegNum();
- spillPhysReg(MBB, I, Reg); // Spill any existing value in the reg
+ spillPhysReg(MBB, I, Reg, true); // Spill any existing value in the reg
PhysRegsUsed[Reg] = 0; // It is free and reserved now
PhysRegsUseOrder.push_back(Reg);
}
// Spill all physical registers holding virtual registers now.
while (!PhysRegsUsed.empty())
- spillVirtReg(MBB, I, PhysRegsUsed.begin()->second,
- PhysRegsUsed.begin()->first);
+ if (unsigned VirtReg = PhysRegsUsed.begin()->second)
+ spillVirtReg(MBB, I, VirtReg, PhysRegsUsed.begin()->first);
+ else
+ removePhysReg(PhysRegsUsed.begin()->first);
for (std::map<unsigned, unsigned>::iterator I = Virt2PhysRegMap.begin(),
E = Virt2PhysRegMap.end(); I != E; ++I)
<< I->second << "\n";
assert(Virt2PhysRegMap.empty() && "Virtual registers still in phys regs?");
- assert(PhysRegsUseOrder.empty() && "Physical regs still allocated?");
+
+ // Clear any physical register which appear live at the end of the basic
+ // block, but which do not hold any virtual registers. e.g., the stack
+ // pointer.
+ PhysRegsUseOrder.clear();
}
return true;
}
-Pass *createLocalRegisterAllocator() {
+FunctionPass *createLocalRegisterAllocator() {
return new RA();
}
projects / oota-llvm.git / blobdiff