/** * Create all blocks and edges for one Func. */ Graph* GraphBuilder::build() { assert(!funcInstrs(m_func).empty()); m_graph = new (m_arena) Graph(); createBlocks(); createExBlocks(); linkBlocks(); linkExBlocks(); return m_graph; }
void computeBytecodeBasicBlocks(CodeBlock* codeBlock, Vector<RefPtr<BytecodeBasicBlock> >& basicBlocks) { Vector<unsigned, 32> jumpTargets; computePreciseJumpTargets(codeBlock, jumpTargets); // Create the entry and exit basic blocks. BytecodeBasicBlock* entry = new BytecodeBasicBlock(BytecodeBasicBlock::EntryBlock); basicBlocks.append(adoptRef(entry)); BytecodeBasicBlock* exit = new BytecodeBasicBlock(BytecodeBasicBlock::ExitBlock); // Find basic block boundaries. BytecodeBasicBlock* current = new BytecodeBasicBlock(0, 0); linkBlocks(entry, current); basicBlocks.append(adoptRef(current)); bool nextInstructionIsLeader = false; Interpreter* interpreter = codeBlock->vm()->interpreter; Instruction* instructionsBegin = codeBlock->instructions().begin(); unsigned instructionCount = codeBlock->instructions().size(); for (unsigned bytecodeOffset = 0; bytecodeOffset < instructionCount;) { OpcodeID opcodeID = interpreter->getOpcodeID(instructionsBegin[bytecodeOffset].u.opcode); unsigned opcodeLength = opcodeLengths[opcodeID]; bool createdBlock = false; // If the current bytecode is a jump target, then it's the leader of its own basic block. if (isJumpTarget(opcodeID, jumpTargets, bytecodeOffset) || nextInstructionIsLeader) { BytecodeBasicBlock* block = new BytecodeBasicBlock(bytecodeOffset, opcodeLength); basicBlocks.append(adoptRef(block)); current = block; createdBlock = true; nextInstructionIsLeader = false; bytecodeOffset += opcodeLength; } // If the current bytecode is a branch or a return, then the next instruction is the leader of its own basic block. if (isBranch(opcodeID) || isTerminal(opcodeID) || isThrow(opcodeID)) nextInstructionIsLeader = true; if (createdBlock) continue; // Otherwise, just add to the length of the current block. current->addBytecodeLength(opcodeLength); bytecodeOffset += opcodeLength; } // Link basic blocks together. for (unsigned i = 0; i < basicBlocks.size(); i++) { BytecodeBasicBlock* block = basicBlocks[i].get(); if (block->isEntryBlock() || block->isExitBlock()) continue; bool fallsThrough = true; for (unsigned bytecodeOffset = block->leaderBytecodeOffset(); bytecodeOffset < block->leaderBytecodeOffset() + block->totalBytecodeLength();) { const Instruction& currentInstruction = instructionsBegin[bytecodeOffset]; OpcodeID opcodeID = interpreter->getOpcodeID(currentInstruction.u.opcode); unsigned opcodeLength = opcodeLengths[opcodeID]; // If we found a terminal bytecode, link to the exit block. if (isTerminal(opcodeID)) { ASSERT(bytecodeOffset + opcodeLength == block->leaderBytecodeOffset() + block->totalBytecodeLength()); linkBlocks(block, exit); fallsThrough = false; break; } // If we found a throw, get the HandlerInfo for this instruction to see where we will jump. // If there isn't one, treat this throw as a terminal. This is true even if we have a finally // block because the finally block will create its own catch, which will generate a HandlerInfo. if (isThrow(opcodeID)) { ASSERT(bytecodeOffset + opcodeLength == block->leaderBytecodeOffset() + block->totalBytecodeLength()); HandlerInfo* handler = codeBlock->handlerForBytecodeOffset(bytecodeOffset); fallsThrough = false; if (!handler) { linkBlocks(block, exit); break; } for (unsigned i = 0; i < basicBlocks.size(); i++) { BytecodeBasicBlock* otherBlock = basicBlocks[i].get(); if (handler->target == otherBlock->leaderBytecodeOffset()) { linkBlocks(block, otherBlock); break; } } break; } // If we found a branch, link to the block(s) that we jump to. if (isBranch(opcodeID)) { ASSERT(bytecodeOffset + opcodeLength == block->leaderBytecodeOffset() + block->totalBytecodeLength()); Vector<unsigned, 1> bytecodeOffsetsJumpedTo; findJumpTargetsForBytecodeOffset(codeBlock, bytecodeOffset, bytecodeOffsetsJumpedTo); for (unsigned i = 0; i < basicBlocks.size(); i++) { BytecodeBasicBlock* otherBlock = basicBlocks[i].get(); if (bytecodeOffsetsJumpedTo.contains(otherBlock->leaderBytecodeOffset())) linkBlocks(block, otherBlock); } if (isUnconditionalBranch(opcodeID)) fallsThrough = false; break; } bytecodeOffset += opcodeLength; } // If we fall through then link to the next block in program order. if (fallsThrough) { ASSERT(i + 1 < basicBlocks.size()); BytecodeBasicBlock* nextBlock = basicBlocks[i + 1].get(); linkBlocks(block, nextBlock); } } basicBlocks.append(adoptRef(exit)); }