Loop::LoopReturn
Loop::init()
{
IonSpew(IonSpew_LICM, "Loop identified, headed by block %d", header_->id());
IonSpew(IonSpew_LICM, "footer is block %d", header_->backedge()->id());
// The first predecessor of the loop header must dominate the header.
JS_ASSERT(header_->id() > header_->getPredecessor(0)->id());
// Loops from backedge to header and marks all visited blocks
// as part of the loop. At the same time add all hoistable instructions
// (in RPO order) to the instruction worklist.
Vector<MBasicBlock *, 1, IonAllocPolicy> inlooplist;
if (!inlooplist.append(header_->backedge()))
return LoopReturn_Error;
header_->backedge()->mark();
while (!inlooplist.empty()) {
MBasicBlock *block = inlooplist.back();
// Hoisting requires more finesse if the loop contains a block that
// self-dominates: there exists control flow that may enter the loop
// without passing through the loop preheader.
//
// Rather than perform a complicated analysis of the dominance graph,
// just return a soft error to ignore this loop.
if (block->immediateDominator() == block) {
while (!worklist_.empty())
popFromWorklist();
return LoopReturn_Skip;
}
// Add not yet visited predecessors to the inlooplist.
if (block != header_) {
for (size_t i = 0; i < block->numPredecessors(); i++) {
MBasicBlock *pred = block->getPredecessor(i);
if (pred->isMarked())
continue;
if (!inlooplist.append(pred))
return LoopReturn_Error;
pred->mark();
}
}
// If any block was added, process them first.
if (block != inlooplist.back())
continue;
// Add all instructions in this block (but the control instruction) to the worklist
for (MInstructionIterator i = block->begin(); i != block->end(); i++) {
MInstruction *ins = *i;
if (isHoistable(ins)) {
if (!insertInWorklist(ins))
return LoopReturn_Error;
}
}
// All successors of this block are visited.
inlooplist.popBack();
}
return LoopReturn_Success;
}
// OSR fixups serve the purpose of representing the non-OSR entry into a loop
// when the only real entry is an OSR entry into the middle. However, if the
// entry into the middle is subsequently folded away, the loop may actually
// have become unreachable. Mark-and-sweep all blocks to remove all such code.
bool ValueNumberer::cleanupOSRFixups()
{
// Mark.
Vector<MBasicBlock*, 0, JitAllocPolicy> worklist(graph_.alloc());
unsigned numMarked = 2;
graph_.entryBlock()->mark();
graph_.osrBlock()->mark();
if (!worklist.append(graph_.entryBlock()) || !worklist.append(graph_.osrBlock()))
return false;
while (!worklist.empty()) {
MBasicBlock* block = worklist.popCopy();
for (size_t i = 0, e = block->numSuccessors(); i != e; ++i) {
MBasicBlock* succ = block->getSuccessor(i);
if (!succ->isMarked()) {
++numMarked;
succ->mark();
if (!worklist.append(succ))
return false;
} else if (succ->isLoopHeader() &&
succ->loopPredecessor() == block &&
succ->numPredecessors() == 3)
{
// Unmark fixup blocks if the loop predecessor is marked after
// the loop header.
succ->getPredecessor(1)->unmarkUnchecked();
}
}
// OSR fixup blocks are needed if and only if the loop header is
// reachable from its backedge (via the OSR block) and not from its
// original loop predecessor.
//
// Thus OSR fixup blocks are removed if the loop header is not
// reachable, or if the loop header is reachable from both its backedge
// and its original loop predecessor.
if (block->isLoopHeader()) {
MBasicBlock* maybeFixupBlock = nullptr;
if (block->numPredecessors() == 2) {
maybeFixupBlock = block->getPredecessor(0);
} else {
MOZ_ASSERT(block->numPredecessors() == 3);
if (!block->loopPredecessor()->isMarked())
maybeFixupBlock = block->getPredecessor(1);
}
if (maybeFixupBlock &&
!maybeFixupBlock->isMarked() &&
maybeFixupBlock->numPredecessors() == 0)
{
MOZ_ASSERT(maybeFixupBlock->numSuccessors() == 1,
"OSR fixup block should have exactly one successor");
MOZ_ASSERT(maybeFixupBlock != graph_.entryBlock(),
"OSR fixup block shouldn't be the entry block");
MOZ_ASSERT(maybeFixupBlock != graph_.osrBlock(),
"OSR fixup block shouldn't be the OSR entry block");
maybeFixupBlock->mark();
}
}
}
// And sweep.
return RemoveUnmarkedBlocks(mir_, graph_, numMarked);
}
