bool run() { const bool extremeLogging = false; bool outerChanged = false; bool innerChanged; do { innerChanged = false; for (BlockIndex blockIndex = 0; blockIndex < m_graph.numBlocks(); ++blockIndex) { BasicBlock* block = m_graph.block(blockIndex); if (!block) continue; ASSERT(block->isReachable); switch (block->last()->op()) { case Jump: { // Successor with one predecessor -> merge. if (block->successor(0)->predecessors.size() == 1) { ASSERT(block->successor(0)->predecessors[0] == block); if (extremeLogging) m_graph.dump(); m_graph.dethread(); mergeBlocks(block, block->successor(0), noBlocks()); innerChanged = outerChanged = true; break; } // FIXME: Block only has a jump -> remove. This is tricky though because of // liveness. What we really want is to slam in a phantom at the end of the // block, after the terminal. But we can't right now. :-( // Idea: what if I slam the ghosties into my successor? Nope, that's // suboptimal, because if my successor has multiple predecessors then we'll // be keeping alive things on other predecessor edges unnecessarily. // What we really need is the notion of end-of-block ghosties! break; } case Branch: { // Branch on constant -> jettison the not-taken block and merge. if (isKnownDirection(block->cfaBranchDirection)) { bool condition = branchCondition(block->cfaBranchDirection); BasicBlock* targetBlock = block->successorForCondition(condition); BasicBlock* jettisonedBlock = block->successorForCondition(!condition); if (targetBlock->predecessors.size() == 1) { if (extremeLogging) m_graph.dump(); m_graph.dethread(); mergeBlocks(block, targetBlock, oneBlock(jettisonedBlock)); } else { if (extremeLogging) m_graph.dump(); m_graph.dethread(); ASSERT(block->last()->isTerminal()); CodeOrigin boundaryCodeOrigin = block->last()->codeOrigin; block->last()->convertToPhantom(); ASSERT(block->last()->refCount() == 1); jettisonBlock(block, jettisonedBlock, boundaryCodeOrigin); block->appendNode( m_graph, SpecNone, Jump, boundaryCodeOrigin, OpInfo(targetBlock)); } innerChanged = outerChanged = true; break; } if (block->successor(0) == block->successor(1)) { convertToJump(block, block->successor(0)); innerChanged = outerChanged = true; break; } // Branch to same destination -> jump. // FIXME: this will currently not be hit because of the lack of jump-only // block simplification. break; } case Switch: { SwitchData* data = block->last()->switchData(); // Prune out cases that end up jumping to default. for (unsigned i = 0; i < data->cases.size(); ++i) { if (data->cases[i].target == data->fallThrough) data->cases[i--] = data->cases.takeLast(); } // If there are no cases other than default then this turns // into a jump. if (data->cases.isEmpty()) { convertToJump(block, data->fallThrough); innerChanged = outerChanged = true; break; } // Switch on constant -> jettison all other targets and merge. if (block->last()->child1()->hasConstant()) { JSValue value = m_graph.valueOfJSConstant(block->last()->child1().node()); TriState found = FalseTriState; BasicBlock* targetBlock = 0; for (unsigned i = data->cases.size(); found == FalseTriState && i--;) { found = data->cases[i].value.strictEqual(value); if (found == TrueTriState) targetBlock = data->cases[i].target; } if (found == MixedTriState) break; if (found == FalseTriState) targetBlock = data->fallThrough; ASSERT(targetBlock); Vector<BasicBlock*, 1> jettisonedBlocks; for (unsigned i = block->numSuccessors(); i--;) { BasicBlock* jettisonedBlock = block->successor(i); if (jettisonedBlock != targetBlock) jettisonedBlocks.append(jettisonedBlock); } if (targetBlock->predecessors.size() == 1) { if (extremeLogging) m_graph.dump(); m_graph.dethread(); mergeBlocks(block, targetBlock, jettisonedBlocks); } else { if (extremeLogging) m_graph.dump(); m_graph.dethread(); CodeOrigin boundaryCodeOrigin = block->last()->codeOrigin; block->last()->convertToPhantom(); for (unsigned i = jettisonedBlocks.size(); i--;) jettisonBlock(block, jettisonedBlocks[i], boundaryCodeOrigin); block->appendNode( m_graph, SpecNone, Jump, boundaryCodeOrigin, OpInfo(targetBlock)); } innerChanged = outerChanged = true; break; } } default: break; } } if (innerChanged) { // Here's the reason for this pass: // Blocks: A, B, C, D, E, F // A -> B, C // B -> F // C -> D, E // D -> F // E -> F // // Assume that A's branch is determined to go to B. Then the rest of this phase // is smart enough to simplify down to: // A -> B // B -> F // C -> D, E // D -> F // E -> F // // We will also merge A and B. But then we don't have any other mechanism to // remove D, E as predecessors for F. Worse, the rest of this phase does not // know how to fix the Phi functions of F to ensure that they no longer refer // to variables in D, E. In general, we need a way to handle Phi simplification // upon: // 1) Removal of a predecessor due to branch simplification. The branch // simplifier already does that. // 2) Invalidation of a predecessor because said predecessor was rendered // unreachable. We do this here. // // This implies that when a block is unreachable, we must inspect its // successors' Phi functions to remove any references from them into the // removed block. m_graph.invalidateCFG(); m_graph.resetReachability(); m_graph.killUnreachableBlocks(); } if (Options::validateGraphAtEachPhase()) validate(m_graph); } while (innerChanged); return outerChanged; }
bool run() { const bool extremeLogging = false; bool outerChanged = false; bool innerChanged; do { innerChanged = false; for (BlockIndex blockIndex = 0; blockIndex < m_graph.m_blocks.size(); ++blockIndex) { BasicBlock* block = m_graph.m_blocks[blockIndex].get(); if (!block) continue; ASSERT(block->isReachable); switch (block->last()->op()) { case Jump: { // Successor with one predecessor -> merge. if (m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors.size() == 1) { ASSERT(m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors[0] == blockIndex); #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE) dataLogF("CFGSimplify: Jump merge on Block #%u to Block #%u.\n", blockIndex, m_graph.successor(block, 0)); #endif if (extremeLogging) m_graph.dump(); m_graph.dethread(); mergeBlocks(blockIndex, m_graph.successor(block, 0), NoBlock); innerChanged = outerChanged = true; break; } else { #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE) dataLogF("Not jump merging on Block #%u to Block #%u because predecessors = ", blockIndex, m_graph.successor(block, 0)); for (unsigned i = 0; i < m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors.size(); ++i) { if (i) dataLogF(", "); dataLogF("#%u", m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors[i]); } dataLogF(".\n"); #endif } // FIXME: Block only has a jump -> remove. This is tricky though because of // liveness. What we really want is to slam in a phantom at the end of the // block, after the terminal. But we can't right now. :-( // Idea: what if I slam the ghosties into my successor? Nope, that's // suboptimal, because if my successor has multiple predecessors then we'll // be keeping alive things on other predecessor edges unnecessarily. // What we really need is the notion of end-of-block ghosties! break; } case Branch: { // Branch on constant -> jettison the not-taken block and merge. if (isKnownDirection(block->cfaBranchDirection)) { bool condition = branchCondition(block->cfaBranchDirection); BasicBlock* targetBlock = m_graph.m_blocks[ m_graph.successorForCondition(block, condition)].get(); if (targetBlock->m_predecessors.size() == 1) { #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE) dataLogF("CFGSimplify: Known condition (%s) branch merge on Block #%u to Block #%u, jettisoning Block #%u.\n", condition ? "true" : "false", blockIndex, m_graph.successorForCondition(block, condition), m_graph.successorForCondition(block, !condition)); #endif if (extremeLogging) m_graph.dump(); m_graph.dethread(); mergeBlocks( blockIndex, m_graph.successorForCondition(block, condition), m_graph.successorForCondition(block, !condition)); } else { #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE) dataLogF("CFGSimplify: Known condition (%s) branch->jump conversion on Block #%u to Block #%u, jettisoning Block #%u.\n", condition ? "true" : "false", blockIndex, m_graph.successorForCondition(block, condition), m_graph.successorForCondition(block, !condition)); #endif if (extremeLogging) m_graph.dump(); m_graph.dethread(); BlockIndex takenBlockIndex = m_graph.successorForCondition(block, condition); BlockIndex notTakenBlockIndex = m_graph.successorForCondition(block, !condition); ASSERT(block->last()->isTerminal()); CodeOrigin boundaryCodeOrigin = block->last()->codeOrigin; block->last()->convertToPhantom(); ASSERT(block->last()->refCount() == 1); jettisonBlock(blockIndex, notTakenBlockIndex, boundaryCodeOrigin); block->appendNode( m_graph, SpecNone, Jump, boundaryCodeOrigin, OpInfo(takenBlockIndex)); } innerChanged = outerChanged = true; break; } if (m_graph.successor(block, 0) == m_graph.successor(block, 1)) { BlockIndex targetBlockIndex = m_graph.successor(block, 0); BasicBlock* targetBlock = m_graph.m_blocks[targetBlockIndex].get(); ASSERT(targetBlock); ASSERT(targetBlock->isReachable); if (targetBlock->m_predecessors.size() == 1) { #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE) dataLogF("CFGSimplify: Branch to same successor merge on Block #%u to Block #%u.\n", blockIndex, targetBlockIndex); #endif m_graph.dethread(); mergeBlocks(blockIndex, targetBlockIndex, NoBlock); } else { #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE) dataLogF("CFGSimplify: Branch->jump conversion to same successor on Block #%u to Block #%u.\n", blockIndex, targetBlockIndex); #endif Node* branch = block->last(); ASSERT(branch->isTerminal()); ASSERT(branch->op() == Branch); branch->convertToPhantom(); ASSERT(branch->refCount() == 1); block->appendNode( m_graph, SpecNone, Jump, branch->codeOrigin, OpInfo(targetBlockIndex)); } innerChanged = outerChanged = true; break; } #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE) dataLogF("Not branch simplifying on Block #%u because the successors differ and the condition is not known.\n", blockIndex); #endif // Branch to same destination -> jump. // FIXME: this will currently not be hit because of the lack of jump-only // block simplification. break; } default: break; } } if (innerChanged) { // Here's the reason for this pass: // Blocks: A, B, C, D, E, F // A -> B, C // B -> F // C -> D, E // D -> F // E -> F // // Assume that A's branch is determined to go to B. Then the rest of this phase // is smart enough to simplify down to: // A -> B // B -> F // C -> D, E // D -> F // E -> F // // We will also merge A and B. But then we don't have any other mechanism to // remove D, E as predecessors for F. Worse, the rest of this phase does not // know how to fix the Phi functions of F to ensure that they no longer refer // to variables in D, E. In general, we need a way to handle Phi simplification // upon: // 1) Removal of a predecessor due to branch simplification. The branch // simplifier already does that. // 2) Invalidation of a predecessor because said predecessor was rendered // unreachable. We do this here. // // This implies that when a block is unreachable, we must inspect its // successors' Phi functions to remove any references from them into the // removed block. m_graph.resetReachability(); for (BlockIndex blockIndex = 0; blockIndex < m_graph.m_blocks.size(); ++blockIndex) { BasicBlock* block = m_graph.m_blocks[blockIndex].get(); if (!block) continue; if (block->isReachable) continue; killUnreachable(blockIndex); } } if (Options::validateGraphAtEachPhase()) validate(m_graph); } while (innerChanged); return outerChanged; }