bool
GreedyAllocator::allocateRegisters()
{
// Allocate registers bottom-up, such that we see all uses before their
// definitions.
for (size_t i = graph.numBlocks() - 1; i < graph.numBlocks(); i--) {
LBlock *block = graph.getBlock(i);
IonSpew(IonSpew_RegAlloc, "Allocating block %d", (uint32)i);
// All registers should be free.
JS_ASSERT(state.free == RegisterSet::All());
// Allocate stack for any phis.
for (size_t j = 0; j < block->numPhis(); j++) {
LPhi *phi = block->getPhi(j);
VirtualRegister *vreg = getVirtualRegister(phi->getDef(0));
allocateStack(vreg);
}
// Allocate registers.
if (!allocateRegistersInBlock(block))
return false;
LMoveGroup *entrySpills = block->getEntryMoveGroup();
// We've reached the top of the block. Spill all registers by inserting
// moves from their stack locations.
for (AnyRegisterIterator iter(RegisterSet::All()); iter.more(); iter++) {
VirtualRegister *vreg = state[*iter];
if (!vreg) {
JS_ASSERT(state.free.has(*iter));
continue;
}
JS_ASSERT(vreg->reg() == *iter);
JS_ASSERT(!state.free.has(vreg->reg()));
allocateStack(vreg);
LAllocation *from = LAllocation::New(vreg->backingStack());
LAllocation *to = LAllocation::New(vreg->reg());
if (!entrySpills->add(from, to))
return false;
killReg(vreg);
vreg->unsetRegister();
}
// Before killing phis, ensure that each phi input has its own stack
// allocation. This ensures we won't allocate the same slot for any phi
// as its input, which technically may be legal (since the phi becomes
// the last use of the slot), but we avoid for sanity.
for (size_t i = 0; i < block->numPhis(); i++) {
LPhi *phi = block->getPhi(i);
for (size_t j = 0; j < phi->numOperands(); j++) {
VirtualRegister *in = getVirtualRegister(phi->getOperand(j)->toUse());
allocateStack(in);
}
}
// Kill phis.
for (size_t i = 0; i < block->numPhis(); i++) {
LPhi *phi = block->getPhi(i);
VirtualRegister *vr = getVirtualRegister(phi->getDef(0));
JS_ASSERT(!vr->hasRegister());
killStack(vr);
}
}
return true;
}
