/*

* Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.

* Copyright (C) 2008 Cameron Zwarich <[email protected]>

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

*

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of

* its contributors may be used to endorse or promote products derived

* from this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "Interpreter.h"

#include "Arguments.h"

#include "BatchedTransitionOptimizer.h"

#include "CallFrame.h"

#include "CallFrameClosure.h"

#include "CodeBlock.h"

#include "Heap.h"

#include "Debugger.h"

#include "DebuggerCallFrame.h"

#include "ErrorInstance.h"

#include "EvalCodeCache.h"

#include "ExceptionHelpers.h"

#include "GetterSetter.h"

#include "JSActivation.h"

#include "JSArray.h"

#include "JSByteArray.h"

#include "JSFunction.h"

#include "JSNotAnObject.h"

#include "JSPropertyNameIterator.h"

#include "LiteralParser.h"

#include "JSStaticScopeObject.h"

#include "JSString.h"

#include "ObjectPrototype.h"

#include "Operations.h"

#include "Parser.h"

#include "Profiler.h"

#include "RegExpObject.h"

#include "RegExpPrototype.h"

#include "Register.h"

#include "SamplingTool.h"

#include "StrictEvalActivation.h"

#include "UStringConcatenate.h"

#include <limits.h>

#include <stdio.h>

#include <wtf/Threading.h>

#if ENABLE(JIT)

#include "JIT.h"

#endif

#define WTF_USE_GCC_COMPUTED_GOTO_WORKAROUND (ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER) && !defined(__llvm__))

using namespace std;

namespace JSC {

// Returns the depth of the scope chain within a given call frame.

static int depth(CodeBlock* codeBlock, ScopeChainNode* sc)

{

if (!codeBlock->needsFullScopeChain())

return 0;

return sc->localDepth();

}

#if ENABLE(CLASSIC_INTERPRETER)

static NEVER_INLINE JSValue concatenateStrings(ExecState* exec, Register* strings, unsigned count)

{

return jsString(exec, strings, count);

}

NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

int dst = vPC[1].u.operand;

int property = vPC[2].u.operand;

ScopeChainNode* scopeChain = callFrame->scopeChain();

ScopeChainIterator iter = scopeChain->begin();

ScopeChainIterator end = scopeChain->end();

ASSERT(iter != end);

CodeBlock* codeBlock = callFrame->codeBlock();

Identifier& ident = codeBlock->identifier(property);

do {

JSObject* o = iter->get();

PropertySlot slot(o);

if (o->getPropertySlot(callFrame, ident, slot)) {

JSValue result = slot.getValue(callFrame, ident);

exceptionValue = callFrame->globalData().exception;

if (exceptionValue)

return false;

callFrame->uncheckedR(dst) = JSValue(result);

return true;

}

} while (++iter != end);

exceptionValue = createUndefinedVariableError(callFrame, ident);

return false;

}

NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

CodeBlock* codeBlock = callFrame->codeBlock();

int dst = vPC[1].u.operand;

int property = vPC[2].u.operand;

int skip = vPC[3].u.operand;

ScopeChainNode* scopeChain = callFrame->scopeChain();

ScopeChainIterator iter = scopeChain->begin();

ScopeChainIterator end = scopeChain->end();

ASSERT(iter != end);

bool checkTopLevel = codeBlock->codeType() == FunctionCode && codeBlock->needsFullScopeChain();

ASSERT(skip || !checkTopLevel);

if (checkTopLevel && skip--) {

if (callFrame->uncheckedR(codeBlock->activationRegister()).jsValue())

++iter;

}

while (skip--) {

++iter;

ASSERT(iter != end);

}

Identifier& ident = codeBlock->identifier(property);

do {

JSObject* o = iter->get();

PropertySlot slot(o);

if (o->getPropertySlot(callFrame, ident, slot)) {

JSValue result = slot.getValue(callFrame, ident);

exceptionValue = callFrame->globalData().exception;

if (exceptionValue)

return false;

ASSERT(result);

callFrame->uncheckedR(dst) = JSValue(result);

return true;

}

} while (++iter != end);

exceptionValue = createUndefinedVariableError(callFrame, ident);

return false;

}

NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

int dst = vPC[1].u.operand;

CodeBlock* codeBlock = callFrame->codeBlock();

JSGlobalObject* globalObject = codeBlock->globalObject();

ASSERT(globalObject->isGlobalObject());

int property = vPC[2].u.operand;

Structure* structure = vPC[3].u.structure.get();

int offset = vPC[4].u.operand;

if (structure == globalObject->structure()) {

callFrame->uncheckedR(dst) = JSValue(globalObject->getDirectOffset(offset));

return true;

}

Identifier& ident = codeBlock->identifier(property);

PropertySlot slot(globalObject);

if (globalObject->getPropertySlot(callFrame, ident, slot)) {

JSValue result = slot.getValue(callFrame, ident);

if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {

vPC[3].u.structure.set(callFrame->globalData(), codeBlock->ownerExecutable(), globalObject->structure());

vPC[4] = slot.cachedOffset();

callFrame->uncheckedR(dst) = JSValue(result);

return true;

}

exceptionValue = callFrame->globalData().exception;

if (exceptionValue)

return false;

callFrame->uncheckedR(dst) = JSValue(result);

return true;

}

exceptionValue = createUndefinedVariableError(callFrame, ident);

return false;

}

NEVER_INLINE bool Interpreter::resolveGlobalDynamic(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

int dst = vPC[1].u.operand;

CodeBlock* codeBlock = callFrame->codeBlock();

JSGlobalObject* globalObject = codeBlock->globalObject();

ASSERT(globalObject->isGlobalObject());

int property = vPC[2].u.operand;

Structure* structure = vPC[3].u.structure.get();

int offset = vPC[4].u.operand;

int skip = vPC[5].u.operand;

ScopeChainNode* scopeChain = callFrame->scopeChain();

ScopeChainIterator iter = scopeChain->begin();

ScopeChainIterator end = scopeChain->end();

ASSERT(iter != end);

bool checkTopLevel = codeBlock->codeType() == FunctionCode && codeBlock->needsFullScopeChain();

ASSERT(skip || !checkTopLevel);

if (checkTopLevel && skip--) {

if (callFrame->uncheckedR(codeBlock->activationRegister()).jsValue())

++iter;

}

while (skip--) {

JSObject* o = iter->get();

if (o->hasCustomProperties()) {

Identifier& ident = codeBlock->identifier(property);

do {

PropertySlot slot(o);

if (o->getPropertySlot(callFrame, ident, slot)) {

JSValue result = slot.getValue(callFrame, ident);

exceptionValue = callFrame->globalData().exception;

if (exceptionValue)

return false;

ASSERT(result);

callFrame->uncheckedR(dst) = JSValue(result);

return true;

}

if (iter == end)

break;

o = iter->get();

++iter;

} while (true);

exceptionValue = createUndefinedVariableError(callFrame, ident);

return false;

}

++iter;

}

if (structure == globalObject->structure()) {

callFrame->uncheckedR(dst) = JSValue(globalObject->getDirectOffset(offset));

ASSERT(callFrame->uncheckedR(dst).jsValue());

return true;

}

Identifier& ident = codeBlock->identifier(property);

PropertySlot slot(globalObject);

if (globalObject->getPropertySlot(callFrame, ident, slot)) {

JSValue result = slot.getValue(callFrame, ident);

if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {

vPC[3].u.structure.set(callFrame->globalData(), codeBlock->ownerExecutable(), globalObject->structure());

vPC[4] = slot.cachedOffset();

ASSERT(result);

callFrame->uncheckedR(dst) = JSValue(result);

return true;

}

exceptionValue = callFrame->globalData().exception;

if (exceptionValue)

return false;

ASSERT(result);

callFrame->uncheckedR(dst) = JSValue(result);

return true;

}

exceptionValue = createUndefinedVariableError(callFrame, ident);

return false;

}

NEVER_INLINE void Interpreter::resolveBase(CallFrame* callFrame, Instruction* vPC)

{

int dst = vPC[1].u.operand;

int property = vPC[2].u.operand;

bool isStrictPut = vPC[3].u.operand;

Identifier ident = callFrame->codeBlock()->identifier(property);

JSValue result = JSC::resolveBase(callFrame, ident, callFrame->scopeChain(), isStrictPut);

if (result) {

callFrame->uncheckedR(dst) = result;

ASSERT(callFrame->uncheckedR(dst).jsValue());

} else

callFrame->globalData().exception = createErrorForInvalidGlobalAssignment(callFrame, ident.ustring());

}

NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

int baseDst = vPC[1].u.operand;

int propDst = vPC[2].u.operand;

int property = vPC[3].u.operand;

ScopeChainNode* scopeChain = callFrame->scopeChain();

ScopeChainIterator iter = scopeChain->begin();

ScopeChainIterator end = scopeChain->end();

// FIXME: add scopeDepthIsZero optimization

ASSERT(iter != end);

CodeBlock* codeBlock = callFrame->codeBlock();

Identifier& ident = codeBlock->identifier(property);

JSObject* base;

do {

base = iter->get();

PropertySlot slot(base);

if (base->getPropertySlot(callFrame, ident, slot)) {

JSValue result = slot.getValue(callFrame, ident);

exceptionValue = callFrame->globalData().exception;

if (exceptionValue)

return false;

callFrame->uncheckedR(propDst) = JSValue(result);

callFrame->uncheckedR(baseDst) = JSValue(base);

return true;

}

++iter;

} while (iter != end);

exceptionValue = createUndefinedVariableError(callFrame, ident);

return false;

}

NEVER_INLINE bool Interpreter::resolveThisAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

{

int thisDst = vPC[1].u.operand;

int propDst = vPC[2].u.operand;

int property = vPC[3].u.operand;

ScopeChainNode* scopeChain = callFrame->scopeChain();

ScopeChainIterator iter = scopeChain->begin();

ScopeChainIterator end = scopeChain->end();

// FIXME: add scopeDepthIsZero optimization

ASSERT(iter != end);

CodeBlock* codeBlock = callFrame->codeBlock();

Identifier& ident = codeBlock->identifier(property);

JSObject* base;

do {

base = iter->get();

++iter;

PropertySlot slot(base);

if (base->getPropertySlot(callFrame, ident, slot)) {

JSValue result = slot.getValue(callFrame, ident);

exceptionValue = callFrame->globalData().exception;

if (exceptionValue)

return false;

callFrame->uncheckedR(propDst) = JSValue(result);

// All entries on the scope chain should be EnvironmentRecords (activations etc),

// other then 'with' object, which are directly referenced from the scope chain,

// and the global object. If we hit either an EnvironmentRecord or a global

// object at the end of the scope chain, this is undefined. If we hit a non-

// EnvironmentRecord within the scope chain, pass the base as the this value.

if (iter == end || base->structure()->typeInfo().isEnvironmentRecord())

callFrame->uncheckedR(thisDst) = jsUndefined();

else

callFrame->uncheckedR(thisDst) = JSValue(base);

return true;

}

} while (iter != end);

exceptionValue = createUndefinedVariableError(callFrame, ident);

return false;

}

#endif // ENABLE(CLASSIC_INTERPRETER)

ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argumentCountIncludingThis)

{

// This ensures enough space for the worst case scenario of zero arguments passed by the caller.

if (!registerFile->grow(callFrame->registers() + registerOffset + newCodeBlock->numParameters() + newCodeBlock->m_numCalleeRegisters))

return 0;

if (argumentCountIncludingThis >= newCodeBlock->numParameters()) {

Register* newCallFrame = callFrame->registers() + registerOffset;

return CallFrame::create(newCallFrame);

}

// Too few arguments -- copy arguments, then fill in missing arguments with undefined.

size_t delta = newCodeBlock->numParameters() - argumentCountIncludingThis;

CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset + delta);

Register* dst = &newCallFrame->uncheckedR(CallFrame::thisArgumentOffset());

Register* end = dst - argumentCountIncludingThis;

for ( ; dst != end; --dst)

*dst = *(dst - delta);

end -= delta;

for ( ; dst != end; --dst)

*dst = jsUndefined();

return newCallFrame;

}

#if ENABLE(CLASSIC_INTERPRETER)

static NEVER_INLINE bool isInvalidParamForIn(CallFrame* callFrame, JSValue value, JSValue& exceptionData)

{

if (value.isObject())

return false;

exceptionData = createInvalidParamError(callFrame, "in" , value);

return true;

}

static NEVER_INLINE bool isInvalidParamForInstanceOf(CallFrame* callFrame, JSValue value, JSValue& exceptionData)

{

if (value.isObject() && asObject(value)->structure()->typeInfo().implementsHasInstance())

return false;

exceptionData = createInvalidParamError(callFrame, "instanceof" , value);

return true;

}

#endif

JSValue eval(CallFrame* callFrame)

{

if (!callFrame->argumentCount())

return jsUndefined();

JSValue program = callFrame->argument(0);

if (!program.isString())

return program;

UString programSource = asString(program)->value(callFrame);

if (callFrame->hadException())

return JSValue();

CallFrame* callerFrame = callFrame->callerFrame();

CodeBlock* callerCodeBlock = callerFrame->codeBlock();

ScopeChainNode* callerScopeChain = callerFrame->scopeChain();

EvalExecutable* eval = callerCodeBlock->evalCodeCache().tryGet(callerCodeBlock->isStrictMode(), programSource, callerScopeChain);

if (!eval) {

if (!callerCodeBlock->isStrictMode()) {

// FIXME: We can use the preparser in strict mode, we just need additional logic

// to prevent duplicates.

if (programSource.is8Bit()) {

LiteralParser<LChar> preparser(callFrame, programSource.characters8(), programSource.length(), NonStrictJSON);

if (JSValue parsedObject = preparser.tryLiteralParse())

return parsedObject;

} else {

LiteralParser<UChar> preparser(callFrame, programSource.characters16(), programSource.length(), NonStrictJSON);

if (JSValue parsedObject = preparser.tryLiteralParse())

return parsedObject;

}

}

JSValue exceptionValue;

eval = callerCodeBlock->evalCodeCache().getSlow(callFrame, callerCodeBlock->ownerExecutable(), callerCodeBlock->isStrictMode(), programSource, callerScopeChain, exceptionValue);

ASSERT(!eval == exceptionValue);

if (UNLIKELY(!eval))

return throwError(callFrame, exceptionValue);

}

JSValue thisValue = callerFrame->thisValue();

ASSERT(isValidThisObject(thisValue, callFrame));

Interpreter* interpreter = callFrame->globalData().interpreter;

return interpreter->execute(eval, callFrame, thisValue, callerScopeChain, callFrame->registers() - interpreter->registerFile().begin() + 1 + RegisterFile::CallFrameHeaderSize);

}

CallFrame* loadVarargs(CallFrame* callFrame, RegisterFile* registerFile, JSValue thisValue, JSValue arguments, int firstFreeRegister)

{

if (!arguments) { // f.apply(x, arguments), with arguments unmodified.

unsigned argumentCountIncludingThis = callFrame->argumentCountIncludingThis();

CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + argumentCountIncludingThis + RegisterFile::CallFrameHeaderSize);

if (argumentCountIncludingThis > Arguments::MaxArguments + 1 || !registerFile->grow(newCallFrame->registers())) {

callFrame->globalData().exception = createStackOverflowError(callFrame);

return 0;

}

newCallFrame->setArgumentCountIncludingThis(argumentCountIncludingThis);

newCallFrame->setThisValue(thisValue);

for (size_t i = 0; i < callFrame->argumentCount(); ++i)

newCallFrame->setArgument(i, callFrame->argument(i));

return newCallFrame;

}

if (arguments.isUndefinedOrNull()) {

CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + 1 + RegisterFile::CallFrameHeaderSize);

if (!registerFile->grow(newCallFrame->registers())) {

callFrame->globalData().exception = createStackOverflowError(callFrame);

return 0;

}

newCallFrame->setArgumentCountIncludingThis(1);

newCallFrame->setThisValue(thisValue);

return newCallFrame;

}

if (!arguments.isObject()) {

callFrame->globalData().exception = createInvalidParamError(callFrame, "Function.prototype.apply", arguments);

return 0;

}

if (asObject(arguments)->classInfo() == &Arguments::s_info) {

Arguments* argsObject = asArguments(arguments);

unsigned argCount = argsObject->length(callFrame);

CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));

if (argCount > Arguments::MaxArguments || !registerFile->grow(newCallFrame->registers())) {

callFrame->globalData().exception = createStackOverflowError(callFrame);

return 0;

}

newCallFrame->setArgumentCountIncludingThis(argCount + 1);

newCallFrame->setThisValue(thisValue);

argsObject->copyToArguments(callFrame, newCallFrame, argCount);

return newCallFrame;

}

if (isJSArray(arguments)) {

JSArray* array = asArray(arguments);

unsigned argCount = array->length();

CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));

if (argCount > Arguments::MaxArguments || !registerFile->grow(newCallFrame->registers())) {

callFrame->globalData().exception = createStackOverflowError(callFrame);

return 0;

}

newCallFrame->setArgumentCountIncludingThis(argCount + 1);

newCallFrame->setThisValue(thisValue);

array->copyToArguments(callFrame, newCallFrame, argCount);

return newCallFrame;

}

JSObject* argObject = asObject(arguments);

unsigned argCount = argObject->get(callFrame, callFrame->propertyNames().length).toUInt32(callFrame);

CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));

if (argCount > Arguments::MaxArguments || !registerFile->grow(newCallFrame->registers())) {

callFrame->globalData().exception = createStackOverflowError(callFrame);

return 0;

}

newCallFrame->setArgumentCountIncludingThis(argCount + 1);

newCallFrame->setThisValue(thisValue);

for (size_t i = 0; i < argCount; ++i) {

newCallFrame->setArgument(i, asObject(arguments)->get(callFrame, i));

if (UNLIKELY(callFrame->globalData().exception))

return 0;

}

return newCallFrame;

}

Interpreter::Interpreter()

: m_sampleEntryDepth(0)

, m_reentryDepth(0)

#if !ASSERT_DISABLED

, m_initialized(false)

#endif

, m_enabled(false)

{

}

void Interpreter::initialize(bool canUseJIT)

{

#if ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER)

if (canUseJIT) {

// If the JIT is present, don't use jump destinations for opcodes.

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

Opcode opcode = bitwise_cast<void*>(static_cast<uintptr_t>(i));

m_opcodeTable[i] = opcode;

}

} else {

privateExecute(InitializeAndReturn, 0, 0);

for (int i = 0; i < numOpcodeIDs; ++i)

m_opcodeIDTable.add(m_opcodeTable[i], static_cast<OpcodeID>(i));

m_enabled = true;

}

#else

UNUSED_PARAM(canUseJIT);

#if ENABLE(CLASSIC_INTERPRETER)

m_enabled = true;

#else

m_enabled = false;

#endif

#endif // ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER)

#if !ASSERT_DISABLED

m_initialized = true;

#endif

#if ENABLE(OPCODE_SAMPLING)

enableSampler();

#endif

}

#ifndef NDEBUG

void Interpreter::dumpCallFrame(CallFrame* callFrame)

{

callFrame->codeBlock()->dump(callFrame);

dumpRegisters(callFrame);

}

void Interpreter::dumpRegisters(CallFrame* callFrame)

{

dataLog("Register frame: \n\n");

dataLog("-----------------------------------------------------------------------------\n");

dataLog(" use | address | value \n");

dataLog("-----------------------------------------------------------------------------\n");

CodeBlock* codeBlock = callFrame->codeBlock();

const Register* it;

const Register* end;

JSValue v;

it = callFrame->registers() - RegisterFile::CallFrameHeaderSize - codeBlock->numParameters();

v = (*it).jsValue();

#if USE(JSVALUE32_64)

dataLog("[this] | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v)); ++it;

#else

dataLog("[this] | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v)); ++it;

#endif

end = it + max(codeBlock->numParameters() - 1, 0); // - 1 to skip "this"

if (it != end) {

do {

v = (*it).jsValue();

#if USE(JSVALUE32_64)

dataLog("[param] | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v));

#else

dataLog("[param] | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v));

#endif

++it;

} while (it != end);

}

dataLog("-----------------------------------------------------------------------------\n");

dataLog("[CodeBlock] | %10p | %p \n", it, (*it).codeBlock()); ++it;

dataLog("[ScopeChain] | %10p | %p \n", it, (*it).scopeChain()); ++it;

dataLog("[CallerRegisters] | %10p | %d \n", it, (*it).i()); ++it;

dataLog("[ReturnPC] | %10p | %p \n", it, (*it).vPC()); ++it;

dataLog("[ArgumentCount] | %10p | %d \n", it, (*it).i()); ++it;

dataLog("[Callee] | %10p | %p \n", it, (*it).function()); ++it;

dataLog("-----------------------------------------------------------------------------\n");

int registerCount = 0;

end = it + codeBlock->m_numVars;

if (it != end) {

do {

v = (*it).jsValue();

#if USE(JSVALUE32_64)

dataLog("[r%2d] | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v));

#else

dataLog("[r%2d] | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v));

#endif

++it;

++registerCount;

} while (it != end);

}

dataLog("-----------------------------------------------------------------------------\n");

end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numVars;

if (it != end) {

do {

v = (*it).jsValue();

#if USE(JSVALUE32_64)

dataLog("[r%2d] | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v));

#else

dataLog("[r%2d] | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v));

#endif

++it;

++registerCount;

} while (it != end);

}

dataLog("-----------------------------------------------------------------------------\n");

}

#endif

bool Interpreter::isOpcode(Opcode opcode)

{

#if ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER)

if (!m_enabled)

return opcode >= 0 && static_cast<OpcodeID>(bitwise_cast<uintptr_t>(opcode)) <= op_end;

return opcode != HashTraits<Opcode>::emptyValue()

&& !HashTraits<Opcode>::isDeletedValue(opcode)

&& m_opcodeIDTable.contains(opcode);

#else

return opcode >= 0 && opcode <= op_end;

#endif

}

NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue exceptionValue, unsigned& bytecodeOffset, CodeBlock*& codeBlock)

{

CodeBlock* oldCodeBlock = codeBlock;

ScopeChainNode* scopeChain = callFrame->scopeChain();

if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {

DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);

if (callFrame->callee())

debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());

else

debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());

}

// If this call frame created an activation or an 'arguments' object, tear it off.

if (oldCodeBlock->codeType() == FunctionCode && oldCodeBlock->needsFullScopeChain()) {

if (!callFrame->uncheckedR(oldCodeBlock->activationRegister()).jsValue()) {

oldCodeBlock->createActivation(callFrame);

scopeChain = callFrame->scopeChain();

}

while (!scopeChain->object->inherits(&JSActivation::s_info))

scopeChain = scopeChain->pop();

callFrame->setScopeChain(scopeChain);

JSActivation* activation = asActivation(scopeChain->object.get());

activation->tearOff(*scopeChain->globalData);

if (JSValue arguments = callFrame->uncheckedR(unmodifiedArgumentsRegister(oldCodeBlock->argumentsRegister())).jsValue())

asArguments(arguments)->didTearOffActivation(callFrame->globalData(), activation);

} else if (oldCodeBlock->usesArguments() && !oldCodeBlock->isStrictMode()) {

if (JSValue arguments = callFrame->uncheckedR(unmodifiedArgumentsRegister(oldCodeBlock->argumentsRegister())).jsValue())

asArguments(arguments)->tearOff(callFrame);

}

CallFrame* callerFrame = callFrame->callerFrame();

callFrame->globalData().topCallFrame = callerFrame;

if (callerFrame->hasHostCallFrameFlag())

return false;

codeBlock = callerFrame->codeBlock();

// Because of how the JIT records call site->bytecode offset

// information the JIT reports the bytecodeOffset for the returnPC

// to be at the beginning of the opcode that has caused the call.

// In the interpreter we have an actual return address, which is

// the beginning of next instruction to execute. To get an offset

// inside the call instruction that triggered the exception we

// have to subtract 1.

#if ENABLE(JIT) && ENABLE(CLASSIC_INTERPRETER)

if (callerFrame->globalData().canUseJIT())

bytecodeOffset = codeBlock->bytecodeOffset(callFrame->returnPC());

else

bytecodeOffset = codeBlock->bytecodeOffset(callFrame->returnVPC()) - 1;

#elif ENABLE(JIT)

bytecodeOffset = codeBlock->bytecodeOffset(callFrame->returnPC());

#else

bytecodeOffset = codeBlock->bytecodeOffset(callFrame->returnVPC()) - 1;

#endif

callFrame = callerFrame;

return true;

}

static void appendSourceToError(CallFrame* callFrame, ErrorInstance* exception, unsigned bytecodeOffset)

{

exception->clearAppendSourceToMessage();

if (!callFrame->codeBlock()->hasExpressionInfo())

return;

int startOffset = 0;

int endOffset = 0;

int divotPoint = 0;

CodeBlock* codeBlock = callFrame->codeBlock();

codeBlock->expressionRangeForBytecodeOffset(bytecodeOffset, divotPoint, startOffset, endOffset);

int expressionStart = divotPoint - startOffset;

int expressionStop = divotPoint + endOffset;

if (!expressionStop || expressionStart > codeBlock->source()->length())

return;

JSGlobalData* globalData = &callFrame->globalData();

JSValue jsMessage = exception->getDirect(*globalData, globalData->propertyNames->message);

if (!jsMessage || !jsMessage.isString())

return;

UString message = asString(jsMessage)->value(callFrame);

if (expressionStart < expressionStop)

message = makeUString(message, " (evaluating '", codeBlock->source()->getRange(expressionStart, expressionStop), "')");

else {

// No range information, so give a few characters of context

const StringImpl* data = codeBlock->source()->data();

int dataLength = codeBlock->source()->length();

int start = expressionStart;

int stop = expressionStart;

// Get up to 20 characters of context to the left and right of the divot, clamping to the line.

// then strip whitespace.

while (start > 0 && (expressionStart - start < 20) && (*data)[start - 1] != '\n')

start--;

while (start < (expressionStart - 1) && isStrWhiteSpace((*data)[start]))

start++;

while (stop < dataLength && (stop - expressionStart < 20) && (*data)[stop] != '\n')

stop++;

while (stop > expressionStart && isStrWhiteSpace((*data)[stop - 1]))

stop--;

message = makeUString(message, " (near '...", codeBlock->source()->getRange(start, stop), "...')");

}

exception->putDirect(*globalData, globalData->propertyNames->message, jsString(globalData, message));

}

NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSValue& exceptionValue, unsigned bytecodeOffset)

{

CodeBlock* codeBlock = callFrame->codeBlock();

bool isInterrupt = false;

// Set up the exception object

if (exceptionValue.isObject()) {

JSObject* exception = asObject(exceptionValue);

if (exception->isErrorInstance() && static_cast<ErrorInstance*>(exception)->appendSourceToMessage())

appendSourceToError(callFrame, static_cast<ErrorInstance*>(exception), bytecodeOffset);

// Using hasExpressionInfo to imply we are interested in rich exception info.

if (codeBlock->hasExpressionInfo() && !hasErrorInfo(callFrame, exception)) {

ASSERT(codeBlock->hasLineInfo());

// FIXME: should only really be adding these properties to VM generated exceptions,

// but the inspector currently requires these for all thrown objects.

addErrorInfo(callFrame, exception, codeBlock->lineNumberForBytecodeOffset(bytecodeOffset), codeBlock->ownerExecutable()->source());

}

isInterrupt = isInterruptedExecutionException(exception) || isTerminatedExecutionException(exception);

}

if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {

DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);

bool hasHandler = codeBlock->handlerForBytecodeOffset(bytecodeOffset);

debugger->exception(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->lineNumberForBytecodeOffset(bytecodeOffset), hasHandler);

}

// Calculate an exception handler vPC, unwinding call frames as necessary.

HandlerInfo* handler = 0;

while (isInterrupt || !(handler = codeBlock->handlerForBytecodeOffset(bytecodeOffset))) {

if (!unwindCallFrame(callFrame, exceptionValue, bytecodeOffset, codeBlock)) {

if (Profiler* profiler = *Profiler::enabledProfilerReference())

profiler->exceptionUnwind(callFrame);

return 0;

}

}

if (Profiler* profiler = *Profiler::enabledProfilerReference())

profiler->exceptionUnwind(callFrame);

// Shrink the JS stack, in case stack overflow made it huge.

Register* highWaterMark = 0;

for (CallFrame* callerFrame = callFrame; callerFrame; callerFrame = callerFrame->callerFrame()->removeHostCallFrameFlag()) {

CodeBlock* codeBlock = callerFrame->codeBlock();

if (!codeBlock)

continue;

Register* callerHighWaterMark = callerFrame->registers() + codeBlock->m_numCalleeRegisters;

highWaterMark = max(highWaterMark, callerHighWaterMark);

}

m_registerFile.shrink(highWaterMark);

// Unwind the scope chain within the exception handler's call frame.

ScopeChainNode* scopeChain = callFrame->scopeChain();

int scopeDelta = 0;

if (!codeBlock->needsFullScopeChain() || codeBlock->codeType() != FunctionCode

|| callFrame->uncheckedR(codeBlock->activationRegister()).jsValue())

scopeDelta = depth(codeBlock, scopeChain) - handler->scopeDepth;

ASSERT(scopeDelta >= 0);

while (scopeDelta--)

scopeChain = scopeChain->pop();

callFrame->setScopeChain(scopeChain);

return handler;

}

static inline JSValue checkedReturn(JSValue returnValue)

{

ASSERT(returnValue);

return returnValue;

}

static inline JSObject* checkedReturn(JSObject* returnValue)

{

ASSERT(returnValue);

return returnValue;

}

JSValue Interpreter::execute(ProgramExecutable* program, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj)

{

ASSERT(isValidThisObject(thisObj, callFrame));

ASSERT(!scopeChain->globalData->exception);

ASSERT(!callFrame->globalData().isCollectorBusy());

if (callFrame->globalData().isCollectorBusy())

return jsNull();

if (m_reentryDepth >= MaxSmallThreadReentryDepth && m_reentryDepth >= callFrame->globalData().maxReentryDepth)

return checkedReturn(throwStackOverflowError(callFrame));

DynamicGlobalObjectScope globalObjectScope(*scopeChain->globalData, scopeChain->globalObject.get());

Vector<JSONPData> JSONPData;

bool parseResult;

const UString programSource = program->source().toString();

if (programSource.isNull())

return jsUndefined();

if (programSource.is8Bit()) {

LiteralParser<LChar> literalParser(callFrame, programSource.characters8(), programSource.length(), JSONP);

parseResult = literalParser.tryJSONPParse(JSONPData, scopeChain->globalObject->globalObjectMethodTable()->supportsRichSourceInfo(scopeChain->globalObject.get()));

} else {

LiteralParser<UChar> literalParser(callFrame, programSource.characters16(), programSource.length(), JSONP);

parseResult = literalParser.tryJSONPParse(JSONPData, scopeChain->globalObject->globalObjectMethodTable()->supportsRichSourceInfo(scopeChain->globalObject.get()));

}

if (parseResult) {

JSGlobalObject* globalObject = scopeChain->globalObject.get();

JSValue result;

for (unsigned entry = 0; entry < JSONPData.size(); entry++) {

Vector<JSONPPathEntry> JSONPPath;

JSONPPath.swap(JSONPData[entry].m_path);

JSValue JSONPValue = JSONPData[entry].m_value.get();

if (JSONPPath.size() == 1 && JSONPPath[0].m_type == JSONPPathEntryTypeDeclare) {

if (globalObject->hasProperty(callFrame, JSONPPath[0].m_pathEntryName)) {

PutPropertySlot slot;

globalObject->methodTable()->put(globalObject, callFrame, JSONPPath[0].m_pathEntryName, JSONPValue, slot);

} else

globalObject->methodTable()->putDirectVirtual(globalObject, callFrame, JSONPPath[0].m_pathEntryName, JSONPValue, DontEnum | DontDelete);

// var declarations return undefined

result = jsUndefined();

continue;

}

JSValue baseObject(globalObject);

for (unsigned i = 0; i < JSONPPath.size() - 1; i++) {

ASSERT(JSONPPath[i].m_type != JSONPPathEntryTypeDeclare);

switch (JSONPPath[i].m_type) {

case JSONPPathEntryTypeDot: {

if (i == 0) {

PropertySlot slot(globalObject);

if (!globalObject->getPropertySlot(callFrame, JSONPPath[i].m_pathEntryName, slot)) {

if (entry)

return throwError(callFrame, createUndefinedVariableError(globalObject->globalExec(), JSONPPath[i].m_pathEntryName));

goto failedJSONP;

}

baseObject = slot.getValue(callFrame, JSONPPath[i].m_pathEntryName);

} else

baseObject = baseObject.get(callFrame, JSONPPath[i].m_pathEntryName);

if (callFrame->hadException())

return jsUndefined();

continue;

}

case JSONPPathEntryTypeLookup: {

baseObject = baseObject.get(callFrame, JSONPPath[i].m_pathIndex);

if (callFrame->hadException())

return jsUndefined();

continue;

}

default:

ASSERT_NOT_REACHED();

return jsUndefined();

}

}

PutPropertySlot slot;

switch (JSONPPath.last().m_type) {

case JSONPPathEntryTypeCall: {

JSValue function = baseObject.get(callFrame, JSONPPath.last().m_pathEntryName);

if (callFrame->hadException())

return jsUndefined();

CallData callData;

CallType callType = getCallData(function, callData);

if (callType == CallTypeNone)

return throwError(callFrame, createNotAFunctionError(callFrame, function));

MarkedArgumentBuffer jsonArg;

jsonArg.append(JSONPValue);

JSValue thisValue = JSONPPath.size() == 1 ? jsUndefined(): baseObject;

JSONPValue = JSC::call(callFrame, function, callType, callData, thisValue, jsonArg);

if (callFrame->hadException())

return jsUndefined();

break;

}

case JSONPPathEntryTypeDot: {

baseObject.put(callFrame, JSONPPath.last().m_pathEntryName, JSONPValue, slot);

if (callFrame->hadException())

return jsUndefined();

break;

}

case JSONPPathEntryTypeLookup: {

baseObject.put(callFrame, JSONPPath.last().m_pathIndex, JSONPValue);

if (callFrame->hadException())

return jsUndefined();

break;

}

default:

ASSERT_NOT_REACHED();

return jsUndefined();

}

result = JSONPValue;

}

return result;

}

failedJSONP:

JSObject* error = program->compile(callFrame, scopeChain);

if (error)

return checkedReturn(throwError(callFrame, error));

CodeBlock* codeBlock = &program->generatedBytecode();

Register* oldEnd = m_registerFile.end();

Register* newEnd = oldEnd + codeBlock->numParameters() + RegisterFile::CallFrameHeaderSize + codeBlock->m_numCalleeRegisters;

if (!m_registerFile.grow(newEnd))

return checkedReturn(throwStackOverflowError(callFrame));

CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->numParameters() + RegisterFile::CallFrameHeaderSize);

ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.

newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), codeBlock->numParameters(), 0);

newCallFrame->setThisValue(thisObj);

TopCallFrameSetter topCallFrame(callFrame->globalData(), newCallFrame);

Profiler** profiler = Profiler::enabledProfilerReference();