ByteCodeParser(Graph& graph)

: m_globalData(&graph.m_globalData)

, m_codeBlock(graph.m_codeBlock)

, m_profiledBlock(graph.m_profiledBlock)

, m_graph(graph)

, m_currentBlock(0)

, m_currentIndex(0)

, m_currentProfilingIndex(0)

, m_constantUndefined(UINT_MAX)

, m_constantNull(UINT_MAX)

, m_constantNaN(UINT_MAX)

, m_constant1(UINT_MAX)

, m_constants(m_codeBlock->numberOfConstantRegisters())

, m_numArguments(m_codeBlock->numParameters())

, m_numLocals(m_codeBlock->m_numCalleeRegisters)

, m_preservedVars(m_codeBlock->m_numVars)

, m_parameterSlots(0)

, m_numPassedVarArgs(0)

, m_globalResolveNumber(0)

, m_inlineStackTop(0)

, m_haveBuiltOperandMaps(false)

, m_emptyJSValueIndex(UINT_MAX)

{

ASSERT(m_profiledBlock);

for (int i = 0; i < m_codeBlock->m_numVars; ++i)

m_preservedVars.set(i);

}

// Parse a full CodeBlock of bytecode.

bool parse();

// Just parse from m_currentIndex to the end of the current CodeBlock.

void parseCodeBlock();

// Helper for min and max.

bool handleMinMax(bool usesResult, int resultOperand, NodeType op, int registerOffset, int argumentCountIncludingThis);

// Handle calls. This resolves issues surrounding inlining and intrinsics.

void handleCall(Interpreter*, Instruction* currentInstruction, NodeType op, CodeSpecializationKind);

void emitFunctionCheck(JSFunction* expectedFunction, NodeIndex callTarget, int registerOffset, CodeSpecializationKind);

// Handle inlining. Return true if it succeeded, false if we need to plant a call.

bool handleInlining(bool usesResult, int callTarget, NodeIndex callTargetNodeIndex, int resultOperand, bool certainAboutExpectedFunction, JSFunction*, int registerOffset, int argumentCountIncludingThis, unsigned nextOffset, CodeSpecializationKind);

// Handle setting the result of an intrinsic.

void setIntrinsicResult(bool usesResult, int resultOperand, NodeIndex);

// Handle intrinsic functions. Return true if it succeeded, false if we need to plant a call.

bool handleIntrinsic(bool usesResult, int resultOperand, Intrinsic, int registerOffset, int argumentCountIncludingThis, PredictedType prediction);

// Prepare to parse a block.

void prepareToParseBlock();

// Parse a single basic block of bytecode instructions.

bool parseBlock(unsigned limit);

// Find reachable code and setup predecessor links in the graph's BasicBlocks.

void determineReachability();

// Enqueue a block onto the worklist, if necessary.

void handleSuccessor(Vector<BlockIndex, 16>& worklist, BlockIndex, BlockIndex successor);

// Link block successors.

void linkBlock(BasicBlock*, Vector<BlockIndex>& possibleTargets);

void linkBlocks(Vector<UnlinkedBlock>& unlinkedBlocks, Vector<BlockIndex>& possibleTargets);

// Link GetLocal & SetLocal nodes, to ensure live values are generated.

enum PhiStackType {

LocalPhiStack,

ArgumentPhiStack

};

template<PhiStackType stackType>

void processPhiStack();

void fixVariableAccessPredictions();

// Add spill locations to nodes.

void allocateVirtualRegisters();

VariableAccessData* newVariableAccessData(int operand)

{

ASSERT(operand < FirstConstantRegisterIndex);

m_graph.m_variableAccessData.append(VariableAccessData(static_cast<VirtualRegister>(operand)));

return &m_graph.m_variableAccessData.last();

}

// Get/Set the operands/result of a bytecode instruction.

NodeIndex getDirect(int operand)

{

// Is this a constant?

if (operand >= FirstConstantRegisterIndex) {

unsigned constant = operand - FirstConstantRegisterIndex;

ASSERT(constant < m_constants.size());

return getJSConstant(constant);

}

// Is this an argument?

if (operandIsArgument(operand))

return getArgument(operand);

// Must be a local.

return getLocal((unsigned)operand);

}

NodeIndex get(int operand)

{

return getDirect(m_inlineStackTop->remapOperand(operand));

}

void setDirect(int operand, NodeIndex value)

{

// Is this an argument?

if (operandIsArgument(operand)) {

setArgument(operand, value);

return;

}

// Must be a local.

setLocal((unsigned)operand, value);

}

void set(int operand, NodeIndex value)

{

setDirect(m_inlineStackTop->remapOperand(operand), value);

}

NodeIndex injectLazyOperandPrediction(NodeIndex nodeIndex)

{

Node& node = m_graph[nodeIndex];

ASSERT(node.op() == GetLocal);

ASSERT(node.codeOrigin.bytecodeIndex == m_currentIndex);

PredictedType prediction =

m_inlineStackTop->m_lazyOperands.prediction(

LazyOperandValueProfileKey(m_currentIndex, node.local()));

#if DFG_ENABLE(DEBUG_VERBOSE)

dataLog("Lazy operand [@%u, bc#%u, r%d] prediction: %s\n",

nodeIndex, m_currentIndex, node.local(), predictionToString(prediction));

#endif

node.variableAccessData()->predict(prediction);

return nodeIndex;

}

// Used in implementing get/set, above, where the operand is a local variable.

NodeIndex getLocal(unsigned operand)

{

NodeIndex nodeIndex = m_currentBlock->variablesAtTail.local(operand);

if (nodeIndex != NoNode) {

Node* nodePtr = &m_graph[nodeIndex];

if (nodePtr->op() == Flush) {

// Two possibilities: either the block wants the local to be live

// but has not loaded its value, or it has loaded its value, in

// which case we're done.

nodeIndex = nodePtr->child1().index();

Node& flushChild = m_graph[nodeIndex];

if (flushChild.op() == Phi) {

VariableAccessData* variableAccessData = flushChild.variableAccessData();

nodeIndex = injectLazyOperandPrediction(addToGraph(GetLocal, OpInfo(variableAccessData), nodeIndex));

m_currentBlock->variablesAtTail.local(operand) = nodeIndex;

return nodeIndex;

}

nodePtr = &flushChild;

}

ASSERT(&m_graph[nodeIndex] == nodePtr);

ASSERT(nodePtr->op() != Flush);

if (m_graph.localIsCaptured(operand)) {

// We wish to use the same variable access data as the previous access,

// but for all other purposes we want to issue a load since for all we

// know, at this stage of compilation, the local has been clobbered.

// Make sure we link to the Phi node, not to the GetLocal.

if (nodePtr->op() == GetLocal)

nodeIndex = nodePtr->child1().index();

return injectLazyOperandPrediction(addToGraph(GetLocal, OpInfo(nodePtr->variableAccessData()), nodeIndex));

}

if (nodePtr->op() == GetLocal)

return nodeIndex;

ASSERT(nodePtr->op() == SetLocal);

return nodePtr->child1().index();

}

// Check for reads of temporaries from prior blocks,

// expand m_preservedVars to cover these.

m_preservedVars.set(operand);

VariableAccessData* variableAccessData = newVariableAccessData(operand);

NodeIndex phi = addToGraph(Phi, OpInfo(variableAccessData));

m_localPhiStack.append(PhiStackEntry(m_currentBlock, phi, operand));

nodeIndex = injectLazyOperandPrediction(addToGraph(GetLocal, OpInfo(variableAccessData), phi));

m_currentBlock->variablesAtTail.local(operand) = nodeIndex;

m_currentBlock->variablesAtHead.setLocalFirstTime(operand, nodeIndex);

return nodeIndex;

}

void setLocal(unsigned operand, NodeIndex value)

{

VariableAccessData* variableAccessData = newVariableAccessData(operand);

NodeIndex nodeIndex = addToGraph(SetLocal, OpInfo(variableAccessData), value);

m_currentBlock->variablesAtTail.local(operand) = nodeIndex;

bool shouldFlush = m_graph.localIsCaptured(operand);

if (!shouldFlush) {

// If this is in argument position, then it should be flushed.

for (InlineStackEntry* stack = m_inlineStackTop; ; stack = stack->m_caller) {

InlineCallFrame* inlineCallFrame = stack->m_inlineCallFrame;

if (!inlineCallFrame)

break;

if (static_cast<int>(operand) >= inlineCallFrame->stackOffset - RegisterFile::CallFrameHeaderSize)

continue;

if (static_cast<int>(operand) == inlineCallFrame->stackOffset + CallFrame::thisArgumentOffset())

continue;

if (operand < inlineCallFrame->stackOffset - RegisterFile::CallFrameHeaderSize - inlineCallFrame->arguments.size())

continue;

int argument = operandToArgument(operand - inlineCallFrame->stackOffset);

stack->m_argumentPositions[argument]->addVariable(variableAccessData);

shouldFlush = true;

break;

}

}

if (shouldFlush)

addToGraph(Flush, OpInfo(variableAccessData), nodeIndex);

}

// Used in implementing get/set, above, where the operand is an argument.

NodeIndex getArgument(unsigned operand)

{

unsigned argument = operandToArgument(operand);

ASSERT(argument < m_numArguments);

NodeIndex nodeIndex = m_currentBlock->variablesAtTail.argument(argument);

if (nodeIndex != NoNode) {

Node* nodePtr = &m_graph[nodeIndex];

if (nodePtr->op() == Flush) {

// Two possibilities: either the block wants the local to be live

// but has not loaded its value, or it has loaded its value, in

// which case we're done.

nodeIndex = nodePtr->child1().index();

Node& flushChild = m_graph[nodeIndex];

if (flushChild.op() == Phi) {

VariableAccessData* variableAccessData = flushChild.variableAccessData();

nodeIndex = injectLazyOperandPrediction(addToGraph(GetLocal, OpInfo(variableAccessData), nodeIndex));

m_currentBlock->variablesAtTail.local(operand) = nodeIndex;

return nodeIndex;

}

nodePtr = &flushChild;

}

ASSERT(&m_graph[nodeIndex] == nodePtr);

ASSERT(nodePtr->op() != Flush);

if (nodePtr->op() == SetArgument) {

// We're getting an argument in the first basic block; link

// the GetLocal to the SetArgument.

ASSERT(nodePtr->local() == static_cast<VirtualRegister>(operand));

nodeIndex = injectLazyOperandPrediction(addToGraph(GetLocal, OpInfo(nodePtr->variableAccessData()), nodeIndex));

m_currentBlock->variablesAtTail.argument(argument) = nodeIndex;

return nodeIndex;

}

if (m_graph.argumentIsCaptured(argument)) {

if (nodePtr->op() == GetLocal)

nodeIndex = nodePtr->child1().index();

return injectLazyOperandPrediction(addToGraph(GetLocal, OpInfo(nodePtr->variableAccessData()), nodeIndex));

}

if (nodePtr->op() == GetLocal)

return nodeIndex;

ASSERT(nodePtr->op() == SetLocal);

return nodePtr->child1().index();

}

VariableAccessData* variableAccessData = newVariableAccessData(operand);

NodeIndex phi = addToGraph(Phi, OpInfo(variableAccessData));

m_argumentPhiStack.append(PhiStackEntry(m_currentBlock, phi, argument));

nodeIndex = injectLazyOperandPrediction(addToGraph(GetLocal, OpInfo(variableAccessData), phi));

m_currentBlock->variablesAtTail.argument(argument) = nodeIndex;

m_currentBlock->variablesAtHead.setArgumentFirstTime(argument, nodeIndex);

return nodeIndex;

}

void setArgument(int operand, NodeIndex value)

{

unsigned argument = operandToArgument(operand);

ASSERT(argument < m_numArguments);

VariableAccessData* variableAccessData = newVariableAccessData(operand);

InlineStackEntry* stack = m_inlineStackTop;

while (stack->m_inlineCallFrame) // find the machine stack entry.

stack = stack->m_caller;

stack->m_argumentPositions[argument]->addVariable(variableAccessData);

NodeIndex nodeIndex = addToGraph(SetLocal, OpInfo(variableAccessData), value);

m_currentBlock->variablesAtTail.argument(argument) = nodeIndex;

// Always flush arguments.

addToGraph(Flush, OpInfo(variableAccessData), nodeIndex);

}

VariableAccessData* flushArgument(int operand)

{

// FIXME: This should check if the same operand had already been flushed to

// some other local variable.

operand = m_inlineStackTop->remapOperand(operand);

ASSERT(operand < FirstConstantRegisterIndex);

NodeIndex nodeIndex;

int index;

if (operandIsArgument(operand)) {

index = operandToArgument(operand);

nodeIndex = m_currentBlock->variablesAtTail.argument(index);

} else {

index = operand;

nodeIndex = m_currentBlock->variablesAtTail.local(index);

m_preservedVars.set(operand);

}

if (nodeIndex != NoNode) {

Node& node = m_graph[nodeIndex];

switch (node.op()) {

case Flush:

nodeIndex = node.child1().index();

break;

case GetLocal:

nodeIndex = node.child1().index();

break;

default:

break;

}

ASSERT(m_graph[nodeIndex].op() != Flush

&& m_graph[nodeIndex].op() != GetLocal);

// Emit a Flush regardless of whether we already flushed it.

// This gives us guidance to see that the variable also needs to be flushed

// for arguments, even if it already had to be flushed for other reasons.

VariableAccessData* variableAccessData = node.variableAccessData();

addToGraph(Flush, OpInfo(variableAccessData), nodeIndex);

return variableAccessData;

}

VariableAccessData* variableAccessData = newVariableAccessData(operand);

NodeIndex phi = addToGraph(Phi, OpInfo(variableAccessData));

nodeIndex = addToGraph(Flush, OpInfo(variableAccessData), phi);

if (operandIsArgument(operand)) {

m_argumentPhiStack.append(PhiStackEntry(m_currentBlock, phi, index));

m_currentBlock->variablesAtTail.argument(index) = nodeIndex;

m_currentBlock->variablesAtHead.setArgumentFirstTime(index, nodeIndex);

} else {

m_localPhiStack.append(PhiStackEntry(m_currentBlock, phi, index));

m_currentBlock->variablesAtTail.local(index) = nodeIndex;

m_currentBlock->variablesAtHead.setLocalFirstTime(index, nodeIndex);

}

return variableAccessData;

}

// Get an operand, and perform a ToInt32/ToNumber conversion on it.

NodeIndex getToInt32(int operand)

{

return toInt32(get(operand));

}

// Perform an ES5 ToInt32 operation - returns a node of type NodeResultInt32.

NodeIndex toInt32(NodeIndex index)

{

Node& node = m_graph[index];

if (node.hasInt32Result())

return index;

if (node.op() == UInt32ToNumber)

return node.child1().index();

// Check for numeric constants boxed as JSValues.

if (node.op() == JSConstant) {

JSValue v = valueOfJSConstant(index);

if (v.isInt32())

return getJSConstant(node.constantNumber());

if (v.isNumber())

return getJSConstantForValue(JSValue(JSC::toInt32(v.asNumber())));

}

return addToGraph(ValueToInt32, index);

}

NodeIndex getJSConstantForValue(JSValue constantValue)

{

unsigned constantIndex = m_codeBlock->addOrFindConstant(constantValue);

if (constantIndex >= m_constants.size())

m_constants.append(ConstantRecord());

ASSERT(m_constants.size() == m_codeBlock->numberOfConstantRegisters());

return getJSConstant(constantIndex);

}

NodeIndex getJSConstant(unsigned constant)

{

NodeIndex index = m_constants[constant].asJSValue;

if (index != NoNode)

return index;

NodeIndex resultIndex = addToGraph(JSConstant, OpInfo(constant));

m_constants[constant].asJSValue = resultIndex;

return resultIndex;

}

// Helper functions to get/set the this value.

NodeIndex getThis()

{

return get(m_inlineStackTop->m_codeBlock->thisRegister());

}

void setThis(NodeIndex value)

{

set(m_inlineStackTop->m_codeBlock->thisRegister(), value);

}

// Convenience methods for checking nodes for constants.

bool isJSConstant(NodeIndex index)

{

return m_graph[index].op() == JSConstant;

}

bool isInt32Constant(NodeIndex nodeIndex)

{

return isJSConstant(nodeIndex) && valueOfJSConstant(nodeIndex).isInt32();

}

// Convenience methods for getting constant values.

JSValue valueOfJSConstant(NodeIndex index)

{

ASSERT(isJSConstant(index));

return m_codeBlock->getConstant(FirstConstantRegisterIndex + m_graph[index].constantNumber());

}

int32_t valueOfInt32Constant(NodeIndex nodeIndex)

{

ASSERT(isInt32Constant(nodeIndex));

return valueOfJSConstant(nodeIndex).asInt32();

}

// This method returns a JSConstant with the value 'undefined'.

NodeIndex constantUndefined()

{

// Has m_constantUndefined been set up yet?

if (m_constantUndefined == UINT_MAX) {

// Search the constant pool for undefined, if we find it, we can just reuse this!

unsigned numberOfConstants = m_codeBlock->numberOfConstantRegisters();

for (m_constantUndefined = 0; m_constantUndefined < numberOfConstants; ++m_constantUndefined) {

JSValue testMe = m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constantUndefined);

if (testMe.isUndefined())

return getJSConstant(m_constantUndefined);

}

// Add undefined to the CodeBlock's constants, and add a corresponding slot in m_constants.

ASSERT(m_constants.size() == numberOfConstants);

m_codeBlock->addConstant(jsUndefined());

m_constants.append(ConstantRecord());

ASSERT(m_constants.size() == m_codeBlock->numberOfConstantRegisters());

}

// m_constantUndefined must refer to an entry in the CodeBlock's constant pool that has the value 'undefined'.

ASSERT(m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constantUndefined).isUndefined());

return getJSConstant(m_constantUndefined);

}

// This method returns a JSConstant with the value 'null'.

NodeIndex constantNull()

{

// Has m_constantNull been set up yet?

if (m_constantNull == UINT_MAX) {

// Search the constant pool for null, if we find it, we can just reuse this!

unsigned numberOfConstants = m_codeBlock->numberOfConstantRegisters();

for (m_constantNull = 0; m_constantNull < numberOfConstants; ++m_constantNull) {

JSValue testMe = m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constantNull);

if (testMe.isNull())

return getJSConstant(m_constantNull);

}

// Add null to the CodeBlock's constants, and add a corresponding slot in m_constants.

ASSERT(m_constants.size() == numberOfConstants);

m_codeBlock->addConstant(jsNull());

m_constants.append(ConstantRecord());

ASSERT(m_constants.size() == m_codeBlock->numberOfConstantRegisters());

}

// m_constantNull must refer to an entry in the CodeBlock's constant pool that has the value 'null'.

ASSERT(m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constantNull).isNull());

return getJSConstant(m_constantNull);

}

// This method returns a DoubleConstant with the value 1.

NodeIndex one()

{

// Has m_constant1 been set up yet?

if (m_constant1 == UINT_MAX) {

// Search the constant pool for the value 1, if we find it, we can just reuse this!

unsigned numberOfConstants = m_codeBlock->numberOfConstantRegisters();

for (m_constant1 = 0; m_constant1 < numberOfConstants; ++m_constant1) {

JSValue testMe = m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constant1);

if (testMe.isInt32() && testMe.asInt32() == 1)

return getJSConstant(m_constant1);

}

// Add the value 1 to the CodeBlock's constants, and add a corresponding slot in m_constants.

ASSERT(m_constants.size() == numberOfConstants);

m_codeBlock->addConstant(jsNumber(1));

m_constants.append(ConstantRecord());

ASSERT(m_constants.size() == m_codeBlock->numberOfConstantRegisters());

}

// m_constant1 must refer to an entry in the CodeBlock's constant pool that has the integer value 1.

ASSERT(m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constant1).isInt32());

ASSERT(m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constant1).asInt32() == 1);

return getJSConstant(m_constant1);

}

// This method returns a DoubleConstant with the value NaN.

NodeIndex constantNaN()

{

JSValue nan = jsNaN();

// Has m_constantNaN been set up yet?

if (m_constantNaN == UINT_MAX) {

// Search the constant pool for the value NaN, if we find it, we can just reuse this!

unsigned numberOfConstants = m_codeBlock->numberOfConstantRegisters();

for (m_constantNaN = 0; m_constantNaN < numberOfConstants; ++m_constantNaN) {

JSValue testMe = m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constantNaN);

if (JSValue::encode(testMe) == JSValue::encode(nan))

return getJSConstant(m_constantNaN);

}

// Add the value nan to the CodeBlock's constants, and add a corresponding slot in m_constants.

ASSERT(m_constants.size() == numberOfConstants);

m_codeBlock->addConstant(nan);

m_constants.append(ConstantRecord());

ASSERT(m_constants.size() == m_codeBlock->numberOfConstantRegisters());

}

// m_constantNaN must refer to an entry in the CodeBlock's constant pool that has the value nan.

ASSERT(m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constantNaN).isDouble());

ASSERT(isnan(m_codeBlock->getConstant(FirstConstantRegisterIndex + m_constantNaN).asDouble()));

return getJSConstant(m_constantNaN);

}

NodeIndex cellConstant(JSCell* cell)

{

HashMap<JSCell*, NodeIndex>::AddResult result = m_cellConstantNodes.add(cell, NoNode);

if (result.isNewEntry)

result.iterator->second = addToGraph(WeakJSConstant, OpInfo(cell));

return result.iterator->second;

}

CodeOrigin currentCodeOrigin()

{

return CodeOrigin(m_currentIndex, m_inlineStackTop->m_inlineCallFrame, m_currentProfilingIndex - m_currentIndex);

}

// These methods create a node and add it to the graph. If nodes of this type are

// 'mustGenerate' then the node will implicitly be ref'ed to ensure generation.

NodeIndex addToGraph(NodeType op, NodeIndex child1 = NoNode, NodeIndex child2 = NoNode, NodeIndex child3 = NoNode)

{

NodeIndex resultIndex = (NodeIndex)m_graph.size();

m_graph.append(Node(op, currentCodeOrigin(), child1, child2, child3));

ASSERT(op != Phi);

m_currentBlock->append(resultIndex);

if (defaultFlags(op) & NodeMustGenerate)

m_graph.ref(resultIndex);

return resultIndex;

}

NodeIndex addToGraph(NodeType op, OpInfo info, NodeIndex child1 = NoNode, NodeIndex child2 = NoNode, NodeIndex child3 = NoNode)

{

NodeIndex resultIndex = (NodeIndex)m_graph.size();

m_graph.append(Node(op, currentCodeOrigin(), info, child1, child2, child3));

if (op == Phi)

m_currentBlock->phis.append(resultIndex);

else

m_currentBlock->append(resultIndex);

if (defaultFlags(op) & NodeMustGenerate)

m_graph.ref(resultIndex);

return resultIndex;

}

NodeIndex addToGraph(NodeType op, OpInfo info1, OpInfo info2, NodeIndex child1 = NoNode, NodeIndex child2 = NoNode, NodeIndex child3 = NoNode)

{

NodeIndex resultIndex = (NodeIndex)m_graph.size();

m_graph.append(Node(op, currentCodeOrigin(), info1, info2, child1, child2, child3));

ASSERT(op != Phi);

m_currentBlock->append(resultIndex);

if (defaultFlags(op) & NodeMustGenerate)

m_graph.ref(resultIndex);

return resultIndex;

}

NodeIndex addToGraph(Node::VarArgTag, NodeType op, OpInfo info1, OpInfo info2)

{

NodeIndex resultIndex = (NodeIndex)m_graph.size();

m_graph.append(Node(Node::VarArg, op, currentCodeOrigin(), info1, info2, m_graph.m_varArgChildren.size() - m_numPassedVarArgs, m_numPassedVarArgs));

ASSERT(op != Phi);

m_currentBlock->append(resultIndex);

m_numPassedVarArgs = 0;

if (defaultFlags(op) & NodeMustGenerate)

m_graph.ref(resultIndex);

return resultIndex;

}

NodeIndex insertPhiNode(OpInfo info, BasicBlock* block)

{

NodeIndex resultIndex = (NodeIndex)m_graph.size();

m_graph.append(Node(Phi, currentCodeOrigin(), info));

block->phis.append(resultIndex);

return resultIndex;

}

void addVarArgChild(NodeIndex child)

{

m_graph.m_varArgChildren.append(Edge(child));

m_numPassedVarArgs++;

}

NodeIndex addCall(Interpreter* interpreter, Instruction* currentInstruction, NodeType op)

{

Instruction* putInstruction = currentInstruction + OPCODE_LENGTH(op_call);

PredictedType prediction = PredictNone;

if (interpreter->getOpcodeID(putInstruction->u.opcode) == op_call_put_result) {

m_currentProfilingIndex = m_currentIndex + OPCODE_LENGTH(op_call);

prediction = getPrediction();

}

addVarArgChild(get(currentInstruction[1].u.operand));

int argCount = currentInstruction[2].u.operand;

if (RegisterFile::CallFrameHeaderSize + (unsigned)argCount > m_parameterSlots)

m_parameterSlots = RegisterFile::CallFrameHeaderSize + argCount;

int registerOffset = currentInstruction[3].u.operand;

int dummyThisArgument = op == Call ? 0 : 1;

for (int i = 0 + dummyThisArgument; i < argCount; ++i)

addVarArgChild(get(registerOffset + argumentToOperand(i)));

NodeIndex call = addToGraph(Node::VarArg, op, OpInfo(0), OpInfo(prediction));

if (interpreter->getOpcodeID(putInstruction->u.opcode) == op_call_put_result)

set(putInstruction[1].u.operand, call);

return call;

}

PredictedType getPredictionWithoutOSRExit(NodeIndex nodeIndex, unsigned bytecodeIndex)

{

UNUSED_PARAM(nodeIndex);

PredictedType prediction = m_inlineStackTop->m_profiledBlock->valueProfilePredictionForBytecodeOffset(bytecodeIndex);

#if DFG_ENABLE(DEBUG_VERBOSE)

dataLog("Dynamic [@%u, bc#%u] prediction: %s\n", nodeIndex, bytecodeIndex, predictionToString(prediction));

#endif

return prediction;

}

PredictedType getPrediction(NodeIndex nodeIndex, unsigned bytecodeIndex)

{

PredictedType prediction = getPredictionWithoutOSRExit(nodeIndex, bytecodeIndex);

if (prediction == PredictNone) {

// We have no information about what values this node generates. Give up

// on executing this code, since we're likely to do more damage than good.

addToGraph(ForceOSRExit);

}

return prediction;

}

PredictedType getPredictionWithoutOSRExit()

{

return getPredictionWithoutOSRExit(m_graph.size(), m_currentProfilingIndex);

}

PredictedType getPrediction()

{

return getPrediction(m_graph.size(), m_currentProfilingIndex);

}

NodeIndex makeSafe(NodeIndex nodeIndex)

{

Node& node = m_graph[nodeIndex];

bool likelyToTakeSlowCase;

if (!isX86() && node.op() == ArithMod)

likelyToTakeSlowCase = false;

else

likelyToTakeSlowCase = m_inlineStackTop->m_profiledBlock->likelyToTakeSlowCase(m_currentIndex);

if (!likelyToTakeSlowCase

&& !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, Overflow)

&& !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, NegativeZero))

return nodeIndex;

switch (m_graph[nodeIndex].op()) {

case UInt32ToNumber:

case ArithAdd:

case ArithSub:

case ArithNegate:

case ValueAdd:

case ArithMod: // for ArithMod "MayOverflow" means we tried to divide by zero, or we saw double.

m_graph[nodeIndex].mergeFlags(NodeMayOverflow);

break;

case ArithMul:

if (m_inlineStackTop->m_profiledBlock->likelyToTakeDeepestSlowCase(m_currentIndex)

|| m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, Overflow)) {

#if DFG_ENABLE(DEBUG_VERBOSE)

dataLog("Making ArithMul @%u take deepest slow case.\n", nodeIndex);

#endif

m_graph[nodeIndex].mergeFlags(NodeMayOverflow | NodeMayNegZero);

} else if (m_inlineStackTop->m_profiledBlock->likelyToTakeSlowCase(m_currentIndex)

|| m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, NegativeZero)) {

#if DFG_ENABLE(DEBUG_VERBOSE)

dataLog("Making ArithMul @%u take faster slow case.\n", nodeIndex);

#endif

m_graph[nodeIndex].mergeFlags(NodeMayNegZero);

}

break;

default:

ASSERT_NOT_REACHED();

break;

}

return nodeIndex;

}

NodeIndex makeDivSafe(NodeIndex nodeIndex)

{

ASSERT(m_graph[nodeIndex].op() == ArithDiv);

// The main slow case counter for op_div in the old JIT counts only when

// the operands are not numbers. We don't care about that since we already

// have speculations in place that take care of that separately. We only

// care about when the outcome of the division is not an integer, which

// is what the special fast case counter tells us.

if (!m_inlineStackTop->m_profiledBlock->likelyToTakeSpecialFastCase(m_currentIndex)

&& !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, Overflow)

&& !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, NegativeZero))

return nodeIndex;

#if DFG_ENABLE(DEBUG_VERBOSE)

dataLog("Making %s @%u safe at bc#%u because special fast-case counter is at %u and exit profiles say %d, %d\n", Graph::opName(m_graph[nodeIndex].op()), nodeIndex, m_currentIndex, m_inlineStackTop->m_profiledBlock->specialFastCaseProfileForBytecodeOffset(m_currentIndex)->m_counter, m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, Overflow), m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, NegativeZero));

#endif

// FIXME: It might be possible to make this more granular. The DFG certainly can

// distinguish between negative zero and overflow in its exit profiles.

m_graph[nodeIndex].mergeFlags(NodeMayOverflow | NodeMayNegZero);

return nodeIndex;

}

bool willNeedFlush(StructureStubInfo& stubInfo)

{

PolymorphicAccessStructureList* list;

int listSize;

switch (stubInfo.accessType) {

case access_get_by_id_self_list:

list = stubInfo.u.getByIdSelfList.structureList;

listSize = stubInfo.u.getByIdSelfList.listSize;

break;

case access_get_by_id_proto_list:

list = stubInfo.u.getByIdProtoList.structureList;

listSize = stubInfo.u.getByIdProtoList.listSize;

break;

default:

return false;

}

for (int i = 0; i < listSize; ++i) {

if (!list->list[i].isDirect)

return true;

}

return false;

}

bool structureChainIsStillValid(bool direct, Structure* previousStructure, StructureChain* chain)

{

if (direct)

return true;

if (!previousStructure->storedPrototype().isNull() && previousStructure->storedPrototype().asCell()->structure() != chain->head()->get())

return false;

for (WriteBarrier<Structure>* it = chain->head(); *it; ++it) {

if (!(*it)->storedPrototype().isNull() && (*it)->storedPrototype().asCell()->structure() != it[1].get())

return false;

}

return true;

}

void buildOperandMapsIfNecessary();

JSGlobalData* m_globalData;

CodeBlock* m_codeBlock;

CodeBlock* m_profiledBlock;

Graph& m_graph;

// The current block being generated.

BasicBlock* m_currentBlock;

// The bytecode index of the current instruction being generated.

unsigned m_currentIndex;

// The bytecode index of the value profile of the current instruction being generated.

unsigned m_currentProfilingIndex;

// We use these values during code generation, and to avoid the need for

// special handling we make sure they are available as constants in the

// CodeBlock's constant pool. These variables are initialized to

// UINT_MAX, and lazily updated to hold an index into the CodeBlock's

// constant pool, as necessary.

unsigned m_constantUndefined;

unsigned m_constantNull;

unsigned m_constantNaN;

unsigned m_constant1;

HashMap<JSCell*, unsigned> m_cellConstants;

HashMap<JSCell*, NodeIndex> m_cellConstantNodes;

// A constant in the constant pool may be represented by more than one

// node in the graph, depending on the context in which it is being used.

struct ConstantRecord {

ConstantRecord()

: asInt32(NoNode)

, asNumeric(NoNode)

, asJSValue(NoNode)

{

}

NodeIndex asInt32;

NodeIndex asNumeric;

NodeIndex asJSValue;

};

// Track the index of the node whose result is the current value for every

// register value in the bytecode - argument, local, and temporary.

Vector<ConstantRecord, 16> m_constants;

// The number of arguments passed to the function.

unsigned m_numArguments;

// The number of locals (vars + temporaries) used in the function.

unsigned m_numLocals;

// The set of registers we need to preserve across BasicBlock boundaries;

// typically equal to the set of vars, but we expand this to cover all

// temporaries that persist across blocks (dues to ?:, &&, ||, etc).

BitVector m_preservedVars;

// The number of slots (in units of sizeof(Register)) that we need to

// preallocate for calls emanating from this frame. This includes the

// size of the CallFrame, only if this is not a leaf function. (I.e.

// this is 0 if and only if this function is a leaf.)

unsigned m_parameterSlots;

// The number of var args passed to the next var arg node.

unsigned m_numPassedVarArgs;

// The index in the global resolve info.

unsigned m_globalResolveNumber;

struct PhiStackEntry {

PhiStackEntry(BasicBlock* block, NodeIndex phi, unsigned varNo)

: m_block(block)

, m_phi(phi)

, m_varNo(varNo)

{

}

BasicBlock* m_block;

NodeIndex m_phi;

unsigned m_varNo;

};

Vector<PhiStackEntry, 16> m_argumentPhiStack;

Vector<PhiStackEntry, 16> m_localPhiStack;

struct InlineStackEntry {

ByteCodeParser* m_byteCodeParser;

CodeBlock* m_codeBlock;

CodeBlock* m_profiledBlock;

InlineCallFrame* m_inlineCallFrame;

VirtualRegister m_calleeVR; // absolute virtual register, not relative to call frame

ScriptExecutable* executable() { return m_codeBlock->ownerExecutable(); }

QueryableExitProfile m_exitProfile;

// Remapping of identifier and constant numbers from the code block being

// inlined (inline callee) to the code block that we're inlining into

// (the machine code block, which is the transitive, though not necessarily

// direct, caller).

Vector<unsigned> m_identifierRemap;

Vector<unsigned> m_constantRemap;

// Blocks introduced by this code block, which need successor linking.

// May include up to one basic block that includes the continuation after

// the callsite in the caller. These must be appended in the order that they

// are created, but their bytecodeBegin values need not be in order as they

// are ignored.

Vector<UnlinkedBlock> m_unlinkedBlocks;

// Potential block linking targets. Must be sorted by bytecodeBegin, and

// cannot have two blocks that have the same bytecodeBegin. For this very

// reason, this is not equivalent to

Vector<BlockIndex> m_blockLinkingTargets;

// If the callsite's basic block was split into two, then this will be

// the head of the callsite block. It needs its successors linked to the

// m_unlinkedBlocks, but not the other way around: there's no way for

// any blocks in m_unlinkedBlocks to jump back into this block.

BlockIndex m_callsiteBlockHead;

// Does the callsite block head need linking? This is typically true

// but will be false for the machine code block's inline stack entry

// (since that one is not inlined) and for cases where an inline callee

// did the linking for us.

bool m_callsiteBlockHeadNeedsLinking;

VirtualRegister m_returnValue;

// Predictions about variable types collected from the profiled code block,

// which are based on OSR exit profiles that past DFG compilatins of this

// code block had gathered.

LazyOperandValueProfileParser m_lazyOperands;

// Did we see any returns? We need to handle the (uncommon but necessary)

// case where a procedure that does not return was inlined.

bool m_didReturn;

// Did we have any early returns?

bool m_didEarlyReturn;

// Pointers to the argument position trackers for this slice of code.

Vector<ArgumentPosition*> m_argumentPositions;

InlineStackEntry* m_caller;

InlineStackEntry(ByteCodeParser*, CodeBlock*, CodeBlock* profiledBlock, BlockIndex callsiteBlockHead, VirtualRegister calleeVR, JSFunction* callee, VirtualRegister returnValueVR, VirtualRegister inlineCallFrameStart, CodeSpecializationKind);

~InlineStackEntry()

{

m_byteCodeParser->m_inlineStackTop = m_caller;

}

int remapOperand(int operand) const

{

if (!m_inlineCallFrame)

return operand;

if (operand >= FirstConstantRegisterIndex) {

int result = m_constantRemap[operand - FirstConstantRegisterIndex];