X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/9bcd318d5fa2a38139c9651d263a06c797529333..b80e619319b1def83d1e8b4f84042b661be1be7f:/interpreter/Interpreter.cpp diff --git a/interpreter/Interpreter.cpp b/interpreter/Interpreter.cpp index a45773c..9821c51 100644 --- a/interpreter/Interpreter.cpp +++ b/interpreter/Interpreter.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008, 2009 Apple Inc. All rights reserved. + * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved. * Copyright (C) 2008 Cameron Zwarich * * Redistribution and use in source and binary forms, with or without @@ -32,11 +32,15 @@ #include "Arguments.h" #include "BatchedTransitionOptimizer.h" +#include "CallFrame.h" +#include "CallFrameClosure.h" #include "CodeBlock.h" +#include "Collector.h" +#include "Debugger.h" #include "DebuggerCallFrame.h" #include "EvalCodeCache.h" #include "ExceptionHelpers.h" -#include "CallFrame.h" +#include "GetterSetter.h" #include "GlobalEvalFunction.h" #include "JSActivation.h" #include "JSArray.h" @@ -44,60 +48,44 @@ #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 "Collector.h" -#include "Debugger.h" -#include "Operations.h" #include "SamplingTool.h" +#include #include +#include #if ENABLE(JIT) #include "JIT.h" #endif -#if ENABLE(ASSEMBLER) -#include "AssemblerBuffer.h" -#endif - -#if PLATFORM(DARWIN) -#include -#endif - -#if HAVE(SYS_TIME_H) -#include -#endif - -#if PLATFORM(WIN_OS) -#include -#endif - -#if PLATFORM(QT) -#include -#endif +#define WTF_USE_GCC_COMPUTED_GOTO_WORKAROUND (ENABLE(COMPUTED_GOTO_INTERPRETER) && !defined(__llvm__)) using namespace std; namespace JSC { - -// Preferred number of milliseconds between each timeout check -static const int preferredScriptCheckTimeInterval = 1000; - -static ALWAYS_INLINE unsigned bytecodeOffsetForPC(CallFrame* callFrame, CodeBlock* codeBlock, void* pc) -{ + #if ENABLE(JIT) - return codeBlock->getBytecodeIndex(callFrame, pc); -#else - UNUSED_PARAM(callFrame); - return static_cast(pc) - codeBlock->instructions().begin(); + static ALWAYS_INLINE unsigned bytecodeOffsetForPC(CallFrame* callFrame, CodeBlock* codeBlock, ReturnAddressPtr pc) + { + return codeBlock->getBytecodeIndex(callFrame, ReturnAddressPtr(pc)); + } +#endif +#if ENABLE(INTERPRETER) + static ALWAYS_INLINE unsigned bytecodeOffsetForPC(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* pc) + { + UNUSED_PARAM(callFrame); + return pc - codeBlock->instructions().begin(); + } #endif -} // Returns the depth of the scope chain within a given call frame. static int depth(CodeBlock* codeBlock, ScopeChain& sc) @@ -107,166 +95,16 @@ static int depth(CodeBlock* codeBlock, ScopeChain& sc) return sc.localDepth(); } -static inline bool jsLess(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2) -{ - if (JSValuePtr::areBothInt32Fast(v1, v2)) - return v1.getInt32Fast() < v2.getInt32Fast(); - - double n1; - double n2; - if (v1.getNumber(n1) && v2.getNumber(n2)) - return n1 < n2; - - Interpreter* interpreter = callFrame->interpreter(); - if (interpreter->isJSString(v1) && interpreter->isJSString(v2)) - return asString(v1)->value() < asString(v2)->value(); - - JSValuePtr p1; - JSValuePtr p2; - bool wasNotString1 = v1.getPrimitiveNumber(callFrame, n1, p1); - bool wasNotString2 = v2.getPrimitiveNumber(callFrame, n2, p2); - - if (wasNotString1 | wasNotString2) - return n1 < n2; - - return asString(p1)->value() < asString(p2)->value(); -} - -static inline bool jsLessEq(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2) -{ - if (JSValuePtr::areBothInt32Fast(v1, v2)) - return v1.getInt32Fast() <= v2.getInt32Fast(); - - double n1; - double n2; - if (v1.getNumber(n1) && v2.getNumber(n2)) - return n1 <= n2; - - Interpreter* interpreter = callFrame->interpreter(); - if (interpreter->isJSString(v1) && interpreter->isJSString(v2)) - return !(asString(v2)->value() < asString(v1)->value()); - - JSValuePtr p1; - JSValuePtr p2; - bool wasNotString1 = v1.getPrimitiveNumber(callFrame, n1, p1); - bool wasNotString2 = v2.getPrimitiveNumber(callFrame, n2, p2); - - if (wasNotString1 | wasNotString2) - return n1 <= n2; - - return !(asString(p2)->value() < asString(p1)->value()); -} - -static NEVER_INLINE JSValuePtr jsAddSlowCase(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2) -{ - // exception for the Date exception in defaultValue() - JSValuePtr p1 = v1.toPrimitive(callFrame); - JSValuePtr p2 = v2.toPrimitive(callFrame); - - if (p1.isString() || p2.isString()) { - RefPtr value = concatenate(p1.toString(callFrame).rep(), p2.toString(callFrame).rep()); - if (!value) - return throwOutOfMemoryError(callFrame); - return jsString(callFrame, value.release()); - } - - return jsNumber(callFrame, p1.toNumber(callFrame) + p2.toNumber(callFrame)); -} - -// Fast-path choices here are based on frequency data from SunSpider: -// Add case: -// --------------------------- -// 5626160 Add case: 3 3 (of these, 3637690 are for immediate values) -// 247412 Add case: 5 5 -// 20900 Add case: 5 6 -// 13962 Add case: 5 3 -// 4000 Add case: 3 5 - -static ALWAYS_INLINE JSValuePtr jsAdd(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2) -{ - double left; - double right = 0.0; - - bool rightIsNumber = v2.getNumber(right); - if (rightIsNumber && v1.getNumber(left)) - return jsNumber(callFrame, left + right); - - bool leftIsString = v1.isString(); - if (leftIsString && v2.isString()) { - RefPtr value = concatenate(asString(v1)->value().rep(), asString(v2)->value().rep()); - if (!value) - return throwOutOfMemoryError(callFrame); - return jsString(callFrame, value.release()); - } - - if (rightIsNumber & leftIsString) { - RefPtr value = v2.isInt32Fast() ? - concatenate(asString(v1)->value().rep(), v2.getInt32Fast()) : - concatenate(asString(v1)->value().rep(), right); - - if (!value) - return throwOutOfMemoryError(callFrame); - return jsString(callFrame, value.release()); - } - - // All other cases are pretty uncommon - return jsAddSlowCase(callFrame, v1, v2); -} - -static JSValuePtr jsTypeStringForValue(CallFrame* callFrame, JSValuePtr v) -{ - if (v.isUndefined()) - return jsNontrivialString(callFrame, "undefined"); - if (v.isBoolean()) - return jsNontrivialString(callFrame, "boolean"); - if (v.isNumber()) - return jsNontrivialString(callFrame, "number"); - if (v.isString()) - return jsNontrivialString(callFrame, "string"); - if (v.isObject()) { - // Return "undefined" for objects that should be treated - // as null when doing comparisons. - if (asObject(v)->structure()->typeInfo().masqueradesAsUndefined()) - return jsNontrivialString(callFrame, "undefined"); - CallData callData; - if (asObject(v)->getCallData(callData) != CallTypeNone) - return jsNontrivialString(callFrame, "function"); - } - return jsNontrivialString(callFrame, "object"); -} - -static bool jsIsObjectType(JSValuePtr v) -{ - if (!v.isCell()) - return v.isNull(); - - JSType type = asCell(v)->structure()->typeInfo().type(); - if (type == NumberType || type == StringType) - return false; - if (type == ObjectType) { - if (asObject(v)->structure()->typeInfo().masqueradesAsUndefined()) - return false; - CallData callData; - if (asObject(v)->getCallData(callData) != CallTypeNone) - return false; - } - return true; -} - -static bool jsIsFunctionType(JSValuePtr v) +#if ENABLE(INTERPRETER) +static NEVER_INLINE JSValue concatenateStrings(ExecState* exec, Register* strings, unsigned count) { - if (v.isObject()) { - CallData callData; - if (asObject(v)->getCallData(callData) != CallTypeNone) - return true; - } - return false; + return jsString(exec, strings, count); } -NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue) +NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue) { - int dst = (vPC + 1)->u.operand; - int property = (vPC + 2)->u.operand; + int dst = vPC[1].u.operand; + int property = vPC[2].u.operand; ScopeChainNode* scopeChain = callFrame->scopeChain(); ScopeChainIterator iter = scopeChain->begin(); @@ -279,11 +117,11 @@ NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, J JSObject* o = *iter; PropertySlot slot(o); if (o->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); + JSValue result = slot.getValue(callFrame, ident); exceptionValue = callFrame->globalData().exception; if (exceptionValue) return false; - callFrame[dst] = JSValuePtr(result); + callFrame->r(dst) = JSValue(result); return true; } } while (++iter != end); @@ -291,13 +129,13 @@ NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, J return false; } -NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue) +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 + codeBlock->needsFullScopeChain(); + int dst = vPC[1].u.operand; + int property = vPC[2].u.operand; + int skip = vPC[3].u.operand + codeBlock->needsFullScopeChain(); ScopeChainNode* scopeChain = callFrame->scopeChain(); ScopeChainIterator iter = scopeChain->begin(); @@ -312,11 +150,11 @@ NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vP JSObject* o = *iter; PropertySlot slot(o); if (o->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); + JSValue result = slot.getValue(callFrame, ident); exceptionValue = callFrame->globalData().exception; if (exceptionValue) return false; - callFrame[dst] = JSValuePtr(result); + callFrame->r(dst) = JSValue(result); return true; } } while (++iter != end); @@ -324,17 +162,17 @@ NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vP return false; } -NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue) +NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue) { - int dst = (vPC + 1)->u.operand; - JSGlobalObject* globalObject = static_cast((vPC + 2)->u.jsCell); + int dst = vPC[1].u.operand; + JSGlobalObject* globalObject = static_cast(vPC[2].u.jsCell); ASSERT(globalObject->isGlobalObject()); - int property = (vPC + 3)->u.operand; - Structure* structure = (vPC + 4)->u.structure; - int offset = (vPC + 5)->u.operand; + int property = vPC[3].u.operand; + Structure* structure = vPC[4].u.structure; + int offset = vPC[5].u.operand; if (structure == globalObject->structure()) { - callFrame[dst] = JSValuePtr(globalObject->getDirectOffset(offset)); + callFrame->r(dst) = JSValue(globalObject->getDirectOffset(offset)); return true; } @@ -342,21 +180,21 @@ NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* Identifier& ident = codeBlock->identifier(property); PropertySlot slot(globalObject); if (globalObject->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); - if (slot.isCacheable() && !globalObject->structure()->isDictionary() && slot.slotBase() == globalObject) { + JSValue result = slot.getValue(callFrame, ident); + if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) { if (vPC[4].u.structure) vPC[4].u.structure->deref(); globalObject->structure()->ref(); vPC[4] = globalObject->structure(); vPC[5] = slot.cachedOffset(); - callFrame[dst] = JSValuePtr(result); + callFrame->r(dst) = JSValue(result); return true; } exceptionValue = callFrame->globalData().exception; if (exceptionValue) return false; - callFrame[dst] = JSValuePtr(result); + callFrame->r(dst) = JSValue(result); return true; } @@ -364,41 +202,88 @@ NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* return false; } -static ALWAYS_INLINE JSValuePtr inlineResolveBase(CallFrame* callFrame, Identifier& property, ScopeChainNode* scopeChain) +NEVER_INLINE bool Interpreter::resolveGlobalDynamic(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue) { + int dst = vPC[1].u.operand; + JSGlobalObject* globalObject = static_cast(vPC[2].u.jsCell); + ASSERT(globalObject->isGlobalObject()); + int property = vPC[3].u.operand; + Structure* structure = vPC[4].u.structure; + int offset = vPC[5].u.operand; + CodeBlock* codeBlock = callFrame->codeBlock(); + int skip = vPC[6].u.operand + codeBlock->needsFullScopeChain(); + + ScopeChainNode* scopeChain = callFrame->scopeChain(); ScopeChainIterator iter = scopeChain->begin(); - ScopeChainIterator next = iter; - ++next; ScopeChainIterator end = scopeChain->end(); ASSERT(iter != end); - - PropertySlot slot; - JSObject* base; - while (true) { - base = *iter; - if (next == end || base->getPropertySlot(callFrame, property, slot)) - return base; - - iter = next; - ++next; + while (skip--) { + JSObject* o = *iter; + 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; + callFrame->r(dst) = JSValue(result); + return true; + } + if (iter == end) + break; + o = *iter; + ++iter; + } while (true); + exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock); + return false; + } + ++iter; + } + + if (structure == globalObject->structure()) { + callFrame->r(dst) = JSValue(globalObject->getDirectOffset(offset)); + return true; } - ASSERT_NOT_REACHED(); - return noValue(); + 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) { + if (vPC[4].u.structure) + vPC[4].u.structure->deref(); + globalObject->structure()->ref(); + vPC[4] = globalObject->structure(); + vPC[5] = slot.cachedOffset(); + callFrame->r(dst) = JSValue(result); + return true; + } + + exceptionValue = callFrame->globalData().exception; + if (exceptionValue) + return false; + callFrame->r(dst) = JSValue(result); + return true; + } + + exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock); + return false; } NEVER_INLINE void Interpreter::resolveBase(CallFrame* callFrame, Instruction* vPC) { - int dst = (vPC + 1)->u.operand; - int property = (vPC + 2)->u.operand; - callFrame[dst] = JSValuePtr(inlineResolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain())); + int dst = vPC[1].u.operand; + int property = vPC[2].u.operand; + callFrame->r(dst) = JSValue(JSC::resolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain())); } -NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue) +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; + 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(); @@ -415,12 +300,12 @@ NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Inst base = *iter; PropertySlot slot(base); if (base->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); + JSValue result = slot.getValue(callFrame, ident); exceptionValue = callFrame->globalData().exception; if (exceptionValue) return false; - callFrame[propDst] = JSValuePtr(result); - callFrame[baseDst] = JSValuePtr(base); + callFrame->r(propDst) = JSValue(result); + callFrame->r(baseDst) = JSValue(base); return true; } ++iter; @@ -430,50 +315,7 @@ NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Inst return false; } -NEVER_INLINE bool Interpreter::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue) -{ - int baseDst = (vPC + 1)->u.operand; - int funcDst = (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; - PropertySlot slot(base); - if (base->getPropertySlot(callFrame, ident, slot)) { - // ECMA 11.2.3 says that if we hit an activation the this value should be null. - // However, section 10.2.3 says that in the case where the value provided - // by the caller is null, the global object should be used. It also says - // that the section does not apply to internal functions, but for simplicity - // of implementation we use the global object anyway here. This guarantees - // that in host objects you always get a valid object for this. - // We also handle wrapper substitution for the global object at the same time. - JSObject* thisObj = base->toThisObject(callFrame); - JSValuePtr result = slot.getValue(callFrame, ident); - exceptionValue = callFrame->globalData().exception; - if (exceptionValue) - return false; - - callFrame[baseDst] = JSValuePtr(thisObj); - callFrame[funcDst] = JSValuePtr(result); - return true; - } - ++iter; - } while (iter != end); - - exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock); - return false; -} +#endif // ENABLE(INTERPRETER) ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc) { @@ -512,91 +354,69 @@ ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newC return CallFrame::create(r); } -static NEVER_INLINE bool isNotObject(CallFrame* callFrame, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValuePtr value, JSValuePtr& exceptionData) +#if ENABLE(INTERPRETER) +static NEVER_INLINE bool isInvalidParamForIn(CallFrame* callFrame, CodeBlock* codeBlock, const Instruction* vPC, JSValue value, JSValue& exceptionData) { if (value.isObject()) return false; - exceptionData = createInvalidParamError(callFrame, forInstanceOf ? "instanceof" : "in" , value, vPC - codeBlock->instructions().begin(), codeBlock); + exceptionData = createInvalidParamError(callFrame, "in" , value, vPC - codeBlock->instructions().begin(), codeBlock); + return true; +} + +static NEVER_INLINE bool isInvalidParamForInstanceOf(CallFrame* callFrame, CodeBlock* codeBlock, const Instruction* vPC, JSValue value, JSValue& exceptionData) +{ + if (value.isObject() && asObject(value)->structure()->typeInfo().implementsHasInstance()) + return false; + exceptionData = createInvalidParamError(callFrame, "instanceof" , value, vPC - codeBlock->instructions().begin(), codeBlock); return true; } +#endif -NEVER_INLINE JSValuePtr Interpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValuePtr& exceptionValue) +NEVER_INLINE JSValue Interpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue& exceptionValue) { if (argc < 2) return jsUndefined(); - JSValuePtr program = argv[1].jsValue(callFrame); + JSValue program = argv[1].jsValue(); if (!program.isString()) return program; - UString programSource = asString(program)->value(); + UString programSource = asString(program)->value(callFrame); + if (callFrame->hadException()) + return JSValue(); + + LiteralParser preparser(callFrame, programSource, LiteralParser::NonStrictJSON); + if (JSValue parsedObject = preparser.tryLiteralParse()) + return parsedObject; ScopeChainNode* scopeChain = callFrame->scopeChain(); CodeBlock* codeBlock = callFrame->codeBlock(); - RefPtr evalNode = codeBlock->evalCodeCache().get(callFrame, programSource, scopeChain, exceptionValue); + RefPtr eval = codeBlock->evalCodeCache().get(callFrame, programSource, scopeChain, exceptionValue); - JSValuePtr result = jsUndefined(); - if (evalNode) - result = callFrame->globalData().interpreter->execute(evalNode.get(), callFrame, callFrame->thisValue().toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue); + JSValue result = jsUndefined(); + if (eval) + result = callFrame->globalData().interpreter->execute(eval.get(), callFrame, callFrame->thisValue().toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue); return result; } Interpreter::Interpreter() - : m_sampler(0) -#if ENABLE(JIT) - , m_ctiArrayLengthTrampoline(0) - , m_ctiStringLengthTrampoline(0) - , m_ctiVirtualCallPreLink(0) - , m_ctiVirtualCallLink(0) - , m_ctiVirtualCall(0) -#endif + : m_sampleEntryDepth(0) , m_reentryDepth(0) - , m_timeoutTime(0) - , m_timeAtLastCheckTimeout(0) - , m_timeExecuting(0) - , m_timeoutCheckCount(0) - , m_ticksUntilNextTimeoutCheck(initialTickCountThreshold) { - initTimeout(); +#if ENABLE(COMPUTED_GOTO_INTERPRETER) privateExecute(InitializeAndReturn, 0, 0, 0); - - // Bizarrely, calling fastMalloc here is faster than allocating space on the stack. - void* storage = fastMalloc(sizeof(CollectorBlock)); - JSCell* jsArray = new (storage) JSArray(JSArray::createStructure(jsNull())); - m_jsArrayVptr = jsArray->vptr(); - jsArray->~JSCell(); - - JSCell* jsByteArray = new (storage) JSByteArray(JSByteArray::VPtrStealingHack); - m_jsByteArrayVptr = jsByteArray->vptr(); - jsByteArray->~JSCell(); - - JSCell* jsString = new (storage) JSString(JSString::VPtrStealingHack); - m_jsStringVptr = jsString->vptr(); - jsString->~JSCell(); - - JSCell* jsFunction = new (storage) JSFunction(JSFunction::createStructure(jsNull())); - m_jsFunctionVptr = jsFunction->vptr(); - jsFunction->~JSCell(); - - fastFree(storage); -} + for (int i = 0; i < numOpcodeIDs; ++i) + m_opcodeIDTable.add(m_opcodeTable[i], static_cast(i)); +#endif // ENABLE(COMPUTED_GOTO_INTERPRETER) -void Interpreter::initialize(JSGlobalData* globalData) -{ -#if ENABLE(JIT) - JIT::compileCTIMachineTrampolines(globalData); -#else - UNUSED_PARAM(globalData); +#if ENABLE(OPCODE_SAMPLING) + enableSampler(); #endif } -Interpreter::~Interpreter() -{ -} - #ifndef NDEBUG void Interpreter::dumpCallFrame(CallFrame* callFrame) @@ -608,84 +428,99 @@ void Interpreter::dumpCallFrame(CallFrame* callFrame) void Interpreter::dumpRegisters(CallFrame* callFrame) { printf("Register frame: \n\n"); - printf("----------------------------------------------------\n"); - printf(" use | address | value \n"); - printf("----------------------------------------------------\n"); + printf("-----------------------------------------------------------------------------\n"); + printf(" use | address | value \n"); + printf("-----------------------------------------------------------------------------\n"); CodeBlock* codeBlock = callFrame->codeBlock(); - RegisterFile* registerFile = &callFrame->scopeChain()->globalObject()->globalData()->interpreter->registerFile(); + RegisterFile* registerFile = &callFrame->scopeChain()->globalObject->globalData()->interpreter->registerFile(); const Register* it; const Register* end; + JSValue v; if (codeBlock->codeType() == GlobalCode) { it = registerFile->lastGlobal(); end = it + registerFile->numGlobals(); while (it != end) { - printf("[global var] | %10p | %10p \n", it, (*it).v()); + v = (*it).jsValue(); +#if USE(JSVALUE32_64) + printf("[global var] | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v)); +#else + printf("[global var] | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v)); +#endif ++it; } - printf("----------------------------------------------------\n"); + printf("-----------------------------------------------------------------------------\n"); } it = callFrame->registers() - RegisterFile::CallFrameHeaderSize - codeBlock->m_numParameters; - printf("[this] | %10p | %10p \n", it, (*it).v()); ++it; + v = (*it).jsValue(); +#if USE(JSVALUE32_64) + printf("[this] | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v)); ++it; +#else + printf("[this] | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v)); ++it; +#endif end = it + max(codeBlock->m_numParameters - 1, 0); // - 1 to skip "this" if (it != end) { do { - printf("[param] | %10p | %10p \n", it, (*it).v()); + v = (*it).jsValue(); +#if USE(JSVALUE32_64) + printf("[param] | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v)); +#else + printf("[param] | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v)); +#endif ++it; } while (it != end); } - printf("----------------------------------------------------\n"); - - printf("[CodeBlock] | %10p | %10p \n", it, (*it).v()); ++it; - printf("[ScopeChain] | %10p | %10p \n", it, (*it).v()); ++it; - printf("[CallerRegisters] | %10p | %10p \n", it, (*it).v()); ++it; - printf("[ReturnPC] | %10p | %10p \n", it, (*it).v()); ++it; - printf("[ReturnValueRegister] | %10p | %10p \n", it, (*it).v()); ++it; - printf("[ArgumentCount] | %10p | %10p \n", it, (*it).v()); ++it; - printf("[Callee] | %10p | %10p \n", it, (*it).v()); ++it; - printf("[OptionalCalleeArguments] | %10p | %10p \n", it, (*it).v()); ++it; - printf("----------------------------------------------------\n"); + printf("-----------------------------------------------------------------------------\n"); + printf("[CodeBlock] | %10p | %p \n", it, (*it).codeBlock()); ++it; + printf("[ScopeChain] | %10p | %p \n", it, (*it).scopeChain()); ++it; + printf("[CallerRegisters] | %10p | %d \n", it, (*it).i()); ++it; + printf("[ReturnPC] | %10p | %p \n", it, (*it).vPC()); ++it; + printf("[ReturnValueRegister] | %10p | %d \n", it, (*it).i()); ++it; + printf("[ArgumentCount] | %10p | %d \n", it, (*it).i()); ++it; + printf("[Callee] | %10p | %p \n", it, (*it).function()); ++it; + printf("[OptionalCalleeArguments] | %10p | %p \n", it, (*it).arguments()); ++it; + printf("-----------------------------------------------------------------------------\n"); int registerCount = 0; end = it + codeBlock->m_numVars; if (it != end) { do { - printf("[r%2d] | %10p | %10p \n", registerCount, it, (*it).v()); - ++it; - ++registerCount; - } while (it != end); - } - printf("----------------------------------------------------\n"); - - end = it + codeBlock->m_numConstants; - if (it != end) { - do { - printf("[r%2d] | %10p | %10p \n", registerCount, it, (*it).v()); + v = (*it).jsValue(); +#if USE(JSVALUE32_64) + printf("[r%2d] | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v)); +#else + printf("[r%2d] | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v)); +#endif ++it; ++registerCount; } while (it != end); } - printf("----------------------------------------------------\n"); + printf("-----------------------------------------------------------------------------\n"); - end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numConstants - codeBlock->m_numVars; + end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numVars; if (it != end) { do { - printf("[r%2d] | %10p | %10p \n", registerCount, it, (*it).v()); + v = (*it).jsValue(); +#if USE(JSVALUE32_64) + printf("[r%2d] | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v)); +#else + printf("[r%2d] | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v)); +#endif ++it; ++registerCount; } while (it != end); } - printf("----------------------------------------------------\n"); + printf("-----------------------------------------------------------------------------\n"); } #endif bool Interpreter::isOpcode(Opcode opcode) { -#if HAVE(COMPUTED_GOTO) +#if ENABLE(COMPUTED_GOTO_INTERPRETER) return opcode != HashTraits::emptyValue() && !HashTraits::isDeletedValue(opcode) && m_opcodeIDTable.contains(opcode); @@ -694,7 +529,7 @@ bool Interpreter::isOpcode(Opcode opcode) #endif } -NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValuePtr exceptionValue, unsigned& bytecodeOffset, CodeBlock*& codeBlock) +NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue exceptionValue, unsigned& bytecodeOffset, CodeBlock*& codeBlock) { CodeBlock* oldCodeBlock = codeBlock; ScopeChainNode* scopeChain = callFrame->scopeChain(); @@ -702,21 +537,21 @@ NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValuePtr if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) { DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue); if (callFrame->callee()) - debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->lastLine()); + debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine()); else - debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->lastLine()); + debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine()); } if (Profiler* profiler = *Profiler::enabledProfilerReference()) { if (callFrame->callee()) profiler->didExecute(callFrame, callFrame->callee()); else - profiler->didExecute(callFrame, codeBlock->ownerNode()->sourceURL(), codeBlock->ownerNode()->lineNo()); + profiler->didExecute(callFrame, codeBlock->ownerExecutable()->sourceURL(), codeBlock->ownerExecutable()->lineNo()); } // If this call frame created an activation or an 'arguments' object, tear it off. if (oldCodeBlock->codeType() == FunctionCode && oldCodeBlock->needsFullScopeChain()) { - while (!scopeChain->object->isObject(&JSActivation::info)) + while (!scopeChain->object->inherits(&JSActivation::info)) scopeChain = scopeChain->pop(); static_cast(scopeChain->object)->copyRegisters(callFrame->optionalCalleeArguments()); } else if (Arguments* arguments = callFrame->optionalCalleeArguments()) { @@ -727,17 +562,28 @@ NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValuePtr if (oldCodeBlock->needsFullScopeChain()) scopeChain->deref(); - void* returnPC = callFrame->returnPC(); - callFrame = callFrame->callerFrame(); - if (callFrame->hasHostCallFrameFlag()) + ExecState* callerFrame = callFrame->callerFrame(); + if (callerFrame->hasHostCallFrameFlag()) return false; - codeBlock = callFrame->codeBlock(); - bytecodeOffset = bytecodeOffsetForPC(callFrame, codeBlock, returnPC); + codeBlock = callerFrame->codeBlock(); +#if ENABLE(JIT) +#if ENABLE(INTERPRETER) + if (callerFrame->globalData().canUseJIT()) +#endif + bytecodeOffset = bytecodeOffsetForPC(callerFrame, codeBlock, callFrame->returnPC()); +#if ENABLE(INTERPRETER) + else + bytecodeOffset = bytecodeOffsetForPC(callerFrame, codeBlock, callFrame->returnVPC()); +#endif +#else + bytecodeOffset = codeBlock->bytecodeOffset(callerFrame, callFrame->returnVPC()); +#endif + callFrame = callerFrame; return true; } -NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSValuePtr& exceptionValue, unsigned bytecodeOffset, bool explicitThrow) +NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSValue& exceptionValue, unsigned bytecodeOffset, bool explicitThrow) { // Set up the exception object @@ -767,11 +613,12 @@ NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSV exception->putWithAttributes(callFrame, Identifier(callFrame, expressionEndOffsetPropertyName), jsNumber(callFrame, divotPoint + endOffset), ReadOnly | DontDelete); } else exception->putWithAttributes(callFrame, Identifier(callFrame, "line"), jsNumber(callFrame, codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset)), ReadOnly | DontDelete); - exception->putWithAttributes(callFrame, Identifier(callFrame, "sourceId"), jsNumber(callFrame, codeBlock->ownerNode()->sourceID()), ReadOnly | DontDelete); - exception->putWithAttributes(callFrame, Identifier(callFrame, "sourceURL"), jsOwnedString(callFrame, codeBlock->ownerNode()->sourceURL()), ReadOnly | DontDelete); + exception->putWithAttributes(callFrame, Identifier(callFrame, "sourceId"), jsNumber(callFrame, codeBlock->ownerExecutable()->sourceID()), ReadOnly | DontDelete); + exception->putWithAttributes(callFrame, Identifier(callFrame, "sourceURL"), jsOwnedString(callFrame, codeBlock->ownerExecutable()->sourceURL()), ReadOnly | DontDelete); } - - if (exception->isWatchdogException()) { + + ComplType exceptionType = exception->exceptionType(); + if (exceptionType == Interrupted || exceptionType == Terminated) { while (unwindCallFrame(callFrame, exceptionValue, bytecodeOffset, codeBlock)) { // Don't need handler checks or anything, we just want to unroll all the JS callframes possible. } @@ -782,22 +629,32 @@ NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSV if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) { DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue); - debugger->exception(debuggerCallFrame, codeBlock->ownerNode()->sourceID(), codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset)); + bool hasHandler = codeBlock->handlerForBytecodeOffset(bytecodeOffset); + debugger->exception(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset), hasHandler); } // If we throw in the middle of a call instruction, we need to notify // the profiler manually that the call instruction has returned, since // we'll never reach the relevant op_profile_did_call. if (Profiler* profiler = *Profiler::enabledProfilerReference()) { -#if !ENABLE(JIT) - if (isCallBytecode(codeBlock->instructions()[bytecodeOffset].u.opcode)) - profiler->didExecute(callFrame, callFrame[codeBlock->instructions()[bytecodeOffset + 2].u.operand].jsValue(callFrame)); - else if (codeBlock->instructions()[bytecodeOffset + 8].u.opcode == getOpcode(op_construct)) - profiler->didExecute(callFrame, callFrame[codeBlock->instructions()[bytecodeOffset + 10].u.operand].jsValue(callFrame)); -#else - int functionRegisterIndex; - if (codeBlock->functionRegisterForBytecodeOffset(bytecodeOffset, functionRegisterIndex)) - profiler->didExecute(callFrame, callFrame[functionRegisterIndex].jsValue(callFrame)); +#if ENABLE(INTERPRETER) + if (!callFrame->globalData().canUseJIT()) { + // FIXME: Why 8? - work out what this magic value is, replace the constant with something more helpful. + if (isCallBytecode(codeBlock->instructions()[bytecodeOffset].u.opcode)) + profiler->didExecute(callFrame, callFrame->r(codeBlock->instructions()[bytecodeOffset + 1].u.operand).jsValue()); + else if (codeBlock->instructions().size() > (bytecodeOffset + 8) && codeBlock->instructions()[bytecodeOffset + 8].u.opcode == getOpcode(op_construct)) + profiler->didExecute(callFrame, callFrame->r(codeBlock->instructions()[bytecodeOffset + 9].u.operand).jsValue()); + } +#if ENABLE(JIT) + else +#endif +#endif +#if ENABLE(JIT) + { + int functionRegisterIndex; + if (codeBlock->functionRegisterForBytecodeOffset(bytecodeOffset, functionRegisterIndex)) + profiler->didExecute(callFrame, callFrame->r(functionRegisterIndex).jsValue()); + } #endif } @@ -822,16 +679,18 @@ NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSV return handler; } -JSValuePtr Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValuePtr* exception) +JSValue Interpreter::execute(ProgramExecutable* program, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue* exception) { ASSERT(!scopeChain->globalData->exception); - if (m_reentryDepth >= MaxReentryDepth) { - *exception = createStackOverflowError(callFrame); - return jsNull(); + if (m_reentryDepth >= MaxSmallThreadReentryDepth) { + if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) { + *exception = createStackOverflowError(callFrame); + return jsNull(); + } } - CodeBlock* codeBlock = &programNode->bytecode(scopeChain); + CodeBlock* codeBlock = &program->bytecode(callFrame, scopeChain); Register* oldEnd = m_registerFile.end(); Register* newEnd = oldEnd + codeBlock->m_numParameters + RegisterFile::CallFrameHeaderSize + codeBlock->m_numCalleeRegisters; @@ -840,14 +699,14 @@ JSValuePtr Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, return jsNull(); } - DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject()); + DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject); JSGlobalObject* lastGlobalObject = m_registerFile.globalObject(); JSGlobalObject* globalObject = callFrame->dynamicGlobalObject(); globalObject->copyGlobalsTo(m_registerFile); CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->m_numParameters + RegisterFile::CallFrameHeaderSize); - newCallFrame[codeBlock->thisRegister()] = JSValuePtr(thisObj); + newCallFrame->r(codeBlock->thisRegister()) = JSValue(thisObj); newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), 0, 0, 0); if (codeBlock->needsFullScopeChain()) @@ -855,25 +714,31 @@ JSValuePtr Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, Profiler** profiler = Profiler::enabledProfilerReference(); if (*profiler) - (*profiler)->willExecute(newCallFrame, programNode->sourceURL(), programNode->lineNo()); + (*profiler)->willExecute(newCallFrame, program->sourceURL(), program->lineNo()); - JSValuePtr result; + JSValue result; { - SamplingTool::CallRecord callRecord(m_sampler); + SamplingTool::CallRecord callRecord(m_sampler.get()); - m_reentryDepth++; + m_reentryDepth++; #if ENABLE(JIT) - if (!codeBlock->jitCode()) - JIT::compile(scopeChain->globalData, codeBlock); - result = JIT::execute(codeBlock->jitCode(), &m_registerFile, newCallFrame, scopeChain->globalData, exception); -#else - result = privateExecute(Normal, &m_registerFile, newCallFrame, exception); +#if ENABLE(INTERPRETER) + if (callFrame->globalData().canUseJIT()) +#endif + result = program->jitCode(newCallFrame, scopeChain).execute(&m_registerFile, newCallFrame, scopeChain->globalData, exception); +#if ENABLE(INTERPRETER) + else +#endif #endif +#if ENABLE(INTERPRETER) + result = privateExecute(Normal, &m_registerFile, newCallFrame, exception); +#endif + m_reentryDepth--; } if (*profiler) - (*profiler)->didExecute(callFrame, programNode->sourceURL(), programNode->lineNo()); + (*profiler)->didExecute(callFrame, program->sourceURL(), program->lineNo()); if (m_reentryDepth && lastGlobalObject && globalObject != lastGlobalObject) lastGlobalObject->copyGlobalsTo(m_registerFile); @@ -883,13 +748,15 @@ JSValuePtr Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, return result; } -JSValuePtr Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValuePtr* exception) +JSValue Interpreter::execute(FunctionExecutable* functionExecutable, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue* exception) { ASSERT(!scopeChain->globalData->exception); - if (m_reentryDepth >= MaxReentryDepth) { - *exception = createStackOverflowError(callFrame); - return jsNull(); + if (m_reentryDepth >= MaxSmallThreadReentryDepth) { + if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) { + *exception = createStackOverflowError(callFrame); + return jsNull(); + } } Register* oldEnd = m_registerFile.end(); @@ -900,16 +767,16 @@ JSValuePtr Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* c return jsNull(); } - DynamicGlobalObjectScope globalObjectScope(callFrame, callFrame->globalData().dynamicGlobalObject ? callFrame->globalData().dynamicGlobalObject : scopeChain->globalObject()); + DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject); CallFrame* newCallFrame = CallFrame::create(oldEnd); size_t dst = 0; - newCallFrame[0] = JSValuePtr(thisObj); + newCallFrame->r(0) = JSValue(thisObj); ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++it) - newCallFrame[++dst] = *it; + newCallFrame->r(++dst) = *it; - CodeBlock* codeBlock = &functionBodyNode->bytecode(scopeChain); + CodeBlock* codeBlock = &functionExecutable->bytecode(callFrame, scopeChain); newCallFrame = slideRegisterWindowForCall(codeBlock, &m_registerFile, newCallFrame, argc + RegisterFile::CallFrameHeaderSize, argc); if (UNLIKELY(!newCallFrame)) { *exception = createStackOverflowError(callFrame); @@ -923,16 +790,21 @@ JSValuePtr Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* c if (*profiler) (*profiler)->willExecute(callFrame, function); - JSValuePtr result; + JSValue result; { - SamplingTool::CallRecord callRecord(m_sampler); + SamplingTool::CallRecord callRecord(m_sampler.get()); m_reentryDepth++; #if ENABLE(JIT) - if (!codeBlock->jitCode()) - JIT::compile(scopeChain->globalData, codeBlock); - result = JIT::execute(codeBlock->jitCode(), &m_registerFile, newCallFrame, scopeChain->globalData, exception); -#else +#if ENABLE(INTERPRETER) + if (scopeChain->globalData->canUseJIT()) +#endif + result = functionExecutable->jitCode(newCallFrame, scopeChain).execute(&m_registerFile, newCallFrame, scopeChain->globalData, exception); +#if ENABLE(INTERPRETER) + else +#endif +#endif +#if ENABLE(INTERPRETER) result = privateExecute(Normal, &m_registerFile, newCallFrame, exception); #endif m_reentryDepth--; @@ -945,54 +817,134 @@ JSValuePtr Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* c return result; } -JSValuePtr Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValuePtr* exception) -{ - return execute(evalNode, callFrame, thisObj, m_registerFile.size() + evalNode->bytecode(scopeChain).m_numParameters + RegisterFile::CallFrameHeaderSize, scopeChain, exception); -} - -JSValuePtr Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValuePtr* exception) +CallFrameClosure Interpreter::prepareForRepeatCall(FunctionExecutable* FunctionExecutable, CallFrame* callFrame, JSFunction* function, int argCount, ScopeChainNode* scopeChain, JSValue* exception) { ASSERT(!scopeChain->globalData->exception); - - if (m_reentryDepth >= MaxReentryDepth) { + + if (m_reentryDepth >= MaxSmallThreadReentryDepth) { + if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) { + *exception = createStackOverflowError(callFrame); + return CallFrameClosure(); + } + } + + Register* oldEnd = m_registerFile.end(); + int argc = 1 + argCount; // implicit "this" parameter + + if (!m_registerFile.grow(oldEnd + argc)) { *exception = createStackOverflowError(callFrame); - return jsNull(); + return CallFrameClosure(); } - DynamicGlobalObjectScope globalObjectScope(callFrame, callFrame->globalData().dynamicGlobalObject ? callFrame->globalData().dynamicGlobalObject : scopeChain->globalObject()); - - EvalCodeBlock* codeBlock = &evalNode->bytecode(scopeChain); - - JSVariableObject* variableObject; - for (ScopeChainNode* node = scopeChain; ; node = node->next) { - ASSERT(node); - if (node->object->isVariableObject()) { - variableObject = static_cast(node->object); - break; - } + CallFrame* newCallFrame = CallFrame::create(oldEnd); + size_t dst = 0; + for (int i = 0; i < argc; ++i) + newCallFrame->r(++dst) = jsUndefined(); + + CodeBlock* codeBlock = &FunctionExecutable->bytecode(callFrame, scopeChain); + newCallFrame = slideRegisterWindowForCall(codeBlock, &m_registerFile, newCallFrame, argc + RegisterFile::CallFrameHeaderSize, argc); + if (UNLIKELY(!newCallFrame)) { + *exception = createStackOverflowError(callFrame); + m_registerFile.shrink(oldEnd); + return CallFrameClosure(); } + // a 0 codeBlock indicates a built-in caller + newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, argc, function); +#if ENABLE(JIT) +#if ENABLE(INTERPRETER) + if (callFrame->globalData().canUseJIT()) +#endif + FunctionExecutable->jitCode(newCallFrame, scopeChain); +#endif + CallFrameClosure result = { callFrame, newCallFrame, function, FunctionExecutable, scopeChain->globalData, oldEnd, scopeChain, codeBlock->m_numParameters, argc }; + return result; +} + +JSValue Interpreter::execute(CallFrameClosure& closure, JSValue* exception) +{ + closure.resetCallFrame(); + Profiler** profiler = Profiler::enabledProfilerReference(); + if (*profiler) + (*profiler)->willExecute(closure.oldCallFrame, closure.function); + + JSValue result; + { + SamplingTool::CallRecord callRecord(m_sampler.get()); + + m_reentryDepth++; +#if ENABLE(JIT) +#if ENABLE(INTERPRETER) + if (closure.newCallFrame->globalData().canUseJIT()) +#endif + result = closure.functionExecutable->generatedJITCode().execute(&m_registerFile, closure.newCallFrame, closure.globalData, exception); +#if ENABLE(INTERPRETER) + else +#endif +#endif +#if ENABLE(INTERPRETER) + result = privateExecute(Normal, &m_registerFile, closure.newCallFrame, exception); +#endif + m_reentryDepth--; + } + + if (*profiler) + (*profiler)->didExecute(closure.oldCallFrame, closure.function); + return result; +} + +void Interpreter::endRepeatCall(CallFrameClosure& closure) +{ + m_registerFile.shrink(closure.oldEnd); +} + +JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue* exception) +{ + return execute(eval, callFrame, thisObj, m_registerFile.size() + eval->bytecode(callFrame, scopeChain).m_numParameters + RegisterFile::CallFrameHeaderSize, scopeChain, exception); +} + +JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValue* exception) +{ + ASSERT(!scopeChain->globalData->exception); + + if (m_reentryDepth >= MaxSmallThreadReentryDepth) { + if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) { + *exception = createStackOverflowError(callFrame); + return jsNull(); + } + } + + DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject); + + EvalCodeBlock* codeBlock = &eval->bytecode(callFrame, scopeChain); + + JSVariableObject* variableObject; + for (ScopeChainNode* node = scopeChain; ; node = node->next) { + ASSERT(node); + if (node->object->isVariableObject()) { + variableObject = static_cast(node->object); + break; + } + } + + unsigned numVariables = codeBlock->numVariables(); + int numFunctions = codeBlock->numberOfFunctionDecls(); + if (numVariables || numFunctions) { + // Scope for BatchedTransitionOptimizer + BatchedTransitionOptimizer optimizer(variableObject); - { // Scope for BatchedTransitionOptimizer - - BatchedTransitionOptimizer optimizer(variableObject); - - const DeclarationStacks::VarStack& varStack = codeBlock->ownerNode()->varStack(); - DeclarationStacks::VarStack::const_iterator varStackEnd = varStack.end(); - for (DeclarationStacks::VarStack::const_iterator it = varStack.begin(); it != varStackEnd; ++it) { - const Identifier& ident = (*it).first; + for (unsigned i = 0; i < numVariables; ++i) { + const Identifier& ident = codeBlock->variable(i); if (!variableObject->hasProperty(callFrame, ident)) { PutPropertySlot slot; variableObject->put(callFrame, ident, jsUndefined(), slot); } } - const DeclarationStacks::FunctionStack& functionStack = codeBlock->ownerNode()->functionStack(); - DeclarationStacks::FunctionStack::const_iterator functionStackEnd = functionStack.end(); - for (DeclarationStacks::FunctionStack::const_iterator it = functionStack.begin(); it != functionStackEnd; ++it) { + for (int i = 0; i < numFunctions; ++i) { + FunctionExecutable* function = codeBlock->functionDecl(i); PutPropertySlot slot; - variableObject->put(callFrame, (*it)->m_ident, (*it)->makeFunction(callFrame, scopeChain), slot); + variableObject->put(callFrame, function->name(), function->make(callFrame, scopeChain), slot); } - } Register* oldEnd = m_registerFile.end(); @@ -1005,7 +957,7 @@ JSValuePtr Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObje CallFrame* newCallFrame = CallFrame::create(m_registerFile.start() + globalRegisterOffset); // a 0 codeBlock indicates a built-in caller - newCallFrame[codeBlock->thisRegister()] = JSValuePtr(thisObj); + newCallFrame->r(codeBlock->thisRegister()) = JSValue(thisObj); newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, 0, 0); if (codeBlock->needsFullScopeChain()) @@ -1013,25 +965,31 @@ JSValuePtr Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObje Profiler** profiler = Profiler::enabledProfilerReference(); if (*profiler) - (*profiler)->willExecute(newCallFrame, evalNode->sourceURL(), evalNode->lineNo()); + (*profiler)->willExecute(newCallFrame, eval->sourceURL(), eval->lineNo()); - JSValuePtr result; + JSValue result; { - SamplingTool::CallRecord callRecord(m_sampler); + SamplingTool::CallRecord callRecord(m_sampler.get()); m_reentryDepth++; + #if ENABLE(JIT) - if (!codeBlock->jitCode()) - JIT::compile(scopeChain->globalData, codeBlock); - result = JIT::execute(codeBlock->jitCode(), &m_registerFile, newCallFrame, scopeChain->globalData, exception); -#else - result = privateExecute(Normal, &m_registerFile, newCallFrame, exception); +#if ENABLE(INTERPRETER) + if (callFrame->globalData().canUseJIT()) +#endif + result = eval->jitCode(newCallFrame, scopeChain).execute(&m_registerFile, newCallFrame, scopeChain->globalData, exception); +#if ENABLE(INTERPRETER) + else +#endif +#endif +#if ENABLE(INTERPRETER) + result = privateExecute(Normal, &m_registerFile, newCallFrame, exception); #endif m_reentryDepth--; } if (*profiler) - (*profiler)->didExecute(callFrame, evalNode->sourceURL(), evalNode->lineNo()); + (*profiler)->didExecute(callFrame, eval->sourceURL(), eval->lineNo()); m_registerFile.shrink(oldEnd); return result; @@ -1045,129 +1003,40 @@ NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHook switch (debugHookID) { case DidEnterCallFrame: - debugger->callEvent(callFrame, callFrame->codeBlock()->ownerNode()->sourceID(), firstLine); + debugger->callEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine); return; case WillLeaveCallFrame: - debugger->returnEvent(callFrame, callFrame->codeBlock()->ownerNode()->sourceID(), lastLine); + debugger->returnEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine); return; case WillExecuteStatement: - debugger->atStatement(callFrame, callFrame->codeBlock()->ownerNode()->sourceID(), firstLine); + debugger->atStatement(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine); return; case WillExecuteProgram: - debugger->willExecuteProgram(callFrame, callFrame->codeBlock()->ownerNode()->sourceID(), firstLine); + debugger->willExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine); return; case DidExecuteProgram: - debugger->didExecuteProgram(callFrame, callFrame->codeBlock()->ownerNode()->sourceID(), lastLine); + debugger->didExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine); return; case DidReachBreakpoint: - debugger->didReachBreakpoint(callFrame, callFrame->codeBlock()->ownerNode()->sourceID(), lastLine); + debugger->didReachBreakpoint(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine); return; } } - -void Interpreter::resetTimeoutCheck() -{ - m_ticksUntilNextTimeoutCheck = initialTickCountThreshold; - m_timeAtLastCheckTimeout = 0; - m_timeExecuting = 0; -} - -// Returns the time the current thread has spent executing, in milliseconds. -static inline unsigned getCPUTime() -{ -#if PLATFORM(DARWIN) - mach_msg_type_number_t infoCount = THREAD_BASIC_INFO_COUNT; - thread_basic_info_data_t info; - - // Get thread information - mach_port_t threadPort = mach_thread_self(); - thread_info(threadPort, THREAD_BASIC_INFO, reinterpret_cast(&info), &infoCount); - mach_port_deallocate(mach_task_self(), threadPort); - - unsigned time = info.user_time.seconds * 1000 + info.user_time.microseconds / 1000; - time += info.system_time.seconds * 1000 + info.system_time.microseconds / 1000; - - return time; -#elif HAVE(SYS_TIME_H) - // FIXME: This should probably use getrusage with the RUSAGE_THREAD flag. - struct timeval tv; - gettimeofday(&tv, 0); - return tv.tv_sec * 1000 + tv.tv_usec / 1000; -#elif PLATFORM(QT) - QDateTime t = QDateTime::currentDateTime(); - return t.toTime_t() * 1000 + t.time().msec(); -#elif PLATFORM(WIN_OS) - union { - FILETIME fileTime; - unsigned long long fileTimeAsLong; - } userTime, kernelTime; - - // GetThreadTimes won't accept NULL arguments so we pass these even though - // they're not used. - FILETIME creationTime, exitTime; - - GetThreadTimes(GetCurrentThread(), &creationTime, &exitTime, &kernelTime.fileTime, &userTime.fileTime); - - return userTime.fileTimeAsLong / 10000 + kernelTime.fileTimeAsLong / 10000; -#else -#error Platform does not have getCurrentTime function -#endif -} - -// We have to return a JSValue here, gcc seems to produce worse code if -// we attempt to return a bool -ALWAYS_INLINE bool Interpreter::checkTimeout(JSGlobalObject* globalObject) -{ - unsigned currentTime = getCPUTime(); - - if (!m_timeAtLastCheckTimeout) { - // Suspicious amount of looping in a script -- start timing it - m_timeAtLastCheckTimeout = currentTime; - return false; - } - - unsigned timeDiff = currentTime - m_timeAtLastCheckTimeout; - - if (timeDiff == 0) - timeDiff = 1; - - m_timeExecuting += timeDiff; - m_timeAtLastCheckTimeout = currentTime; - // Adjust the tick threshold so we get the next checkTimeout call in the interval specified in - // preferredScriptCheckTimeInterval - m_ticksUntilNextTimeoutCheck = static_cast((static_cast(preferredScriptCheckTimeInterval) / timeDiff) * m_ticksUntilNextTimeoutCheck); - // If the new threshold is 0 reset it to the default threshold. This can happen if the timeDiff is higher than the - // preferred script check time interval. - if (m_ticksUntilNextTimeoutCheck == 0) - m_ticksUntilNextTimeoutCheck = initialTickCountThreshold; - - if (globalObject->shouldInterruptScriptBeforeTimeout()) - return true; - - if (m_timeoutTime && m_timeExecuting > m_timeoutTime) { - if (globalObject->shouldInterruptScript()) - return true; - - resetTimeoutCheck(); - } - - return false; -} - +#if ENABLE(INTERPRETER) NEVER_INLINE ScopeChainNode* Interpreter::createExceptionScope(CallFrame* callFrame, const Instruction* vPC) { - int dst = (++vPC)->u.operand; + int dst = vPC[1].u.operand; CodeBlock* codeBlock = callFrame->codeBlock(); - Identifier& property = codeBlock->identifier((++vPC)->u.operand); - JSValuePtr value = callFrame[(++vPC)->u.operand].jsValue(callFrame); + Identifier& property = codeBlock->identifier(vPC[2].u.operand); + JSValue value = callFrame->r(vPC[3].u.operand).jsValue(); JSObject* scope = new (callFrame) JSStaticScopeObject(callFrame, property, value, DontDelete); - callFrame[dst] = JSValuePtr(scope); + callFrame->r(dst) = JSValue(scope); return callFrame->scopeChain()->push(scope); } -NEVER_INLINE void Interpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValuePtr baseValue, const PutPropertySlot& slot) +NEVER_INLINE void Interpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue baseValue, const PutPropertySlot& slot) { // Recursive invocation may already have specialized this instruction. if (vPC[0].u.opcode != getOpcode(op_put_by_id)) @@ -1185,7 +1054,7 @@ NEVER_INLINE void Interpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* JSCell* baseCell = asCell(baseValue); Structure* structure = baseCell->structure(); - if (structure->isDictionary()) { + if (structure->isUncacheableDictionary()) { vPC[0] = getOpcode(op_put_by_id_generic); return; } @@ -1214,6 +1083,14 @@ NEVER_INLINE void Interpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* // Structure transition, cache transition info if (slot.type() == PutPropertySlot::NewProperty) { + if (structure->isDictionary()) { + vPC[0] = getOpcode(op_put_by_id_generic); + return; + } + + // put_by_id_transition checks the prototype chain for setters. + normalizePrototypeChain(callFrame, baseCell); + vPC[0] = getOpcode(op_put_by_id_transition); vPC[4] = structure->previousID(); vPC[5] = structure; @@ -1235,35 +1112,7 @@ NEVER_INLINE void Interpreter::uncachePutByID(CodeBlock* codeBlock, Instruction* vPC[4] = 0; } -static size_t countPrototypeChainEntriesAndCheckForProxies(CallFrame* callFrame, JSValuePtr baseValue, const PropertySlot& slot) -{ - JSCell* cell = asCell(baseValue); - size_t count = 0; - - while (slot.slotBase() != cell) { - JSValuePtr v = cell->structure()->prototypeForLookup(callFrame); - - // If we didn't find slotBase in baseValue's prototype chain, then baseValue - // must be a proxy for another object. - - if (v.isNull()) - return 0; - - cell = asCell(v); - - // Since we're accessing a prototype in a loop, it's a good bet that it - // should not be treated as a dictionary. - if (cell->structure()->isDictionary()) - asObject(cell)->setStructure(Structure::fromDictionaryTransition(cell->structure())); - - ++count; - } - - ASSERT(count); - return count; -} - -NEVER_INLINE void Interpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValuePtr baseValue, const Identifier& propertyName, const PropertySlot& slot) +NEVER_INLINE void Interpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue baseValue, const Identifier& propertyName, const PropertySlot& slot) { // Recursive invocation may already have specialized this instruction. if (vPC[0].u.opcode != getOpcode(op_get_by_id)) @@ -1275,12 +1124,13 @@ NEVER_INLINE void Interpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* return; } - if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) { + JSGlobalData* globalData = &callFrame->globalData(); + if (isJSArray(globalData, baseValue) && propertyName == callFrame->propertyNames().length) { vPC[0] = getOpcode(op_get_array_length); return; } - if (isJSString(baseValue) && propertyName == callFrame->propertyNames().length) { + if (isJSString(globalData, baseValue) && propertyName == callFrame->propertyNames().length) { vPC[0] = getOpcode(op_get_string_length); return; } @@ -1293,7 +1143,7 @@ NEVER_INLINE void Interpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* Structure* structure = asCell(baseValue)->structure(); - if (structure->isDictionary()) { + if (structure->isUncacheableDictionary()) { vPC[0] = getOpcode(op_get_by_id_generic); return; } @@ -1315,42 +1165,90 @@ NEVER_INLINE void Interpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* // Cache hit: Specialize instruction and ref Structures. if (slot.slotBase() == baseValue) { - vPC[0] = getOpcode(op_get_by_id_self); - vPC[5] = slot.cachedOffset(); + switch (slot.cachedPropertyType()) { + case PropertySlot::Getter: + vPC[0] = getOpcode(op_get_by_id_getter_self); + vPC[5] = slot.cachedOffset(); + break; + case PropertySlot::Custom: + vPC[0] = getOpcode(op_get_by_id_custom_self); + vPC[5] = slot.customGetter(); + break; + default: + vPC[0] = getOpcode(op_get_by_id_self); + vPC[5] = slot.cachedOffset(); + break; + } codeBlock->refStructures(vPC); return; } + if (structure->isDictionary()) { + vPC[0] = getOpcode(op_get_by_id_generic); + return; + } + if (slot.slotBase() == structure->prototypeForLookup(callFrame)) { ASSERT(slot.slotBase().isObject()); JSObject* baseObject = asObject(slot.slotBase()); + size_t offset = slot.cachedOffset(); // Since we're accessing a prototype in a loop, it's a good bet that it // should not be treated as a dictionary. - if (baseObject->structure()->isDictionary()) - baseObject->setStructure(Structure::fromDictionaryTransition(baseObject->structure())); + if (baseObject->structure()->isDictionary()) { + baseObject->flattenDictionaryObject(); + offset = baseObject->structure()->get(propertyName); + } - vPC[0] = getOpcode(op_get_by_id_proto); + ASSERT(!baseObject->structure()->isUncacheableDictionary()); + + switch (slot.cachedPropertyType()) { + case PropertySlot::Getter: + vPC[0] = getOpcode(op_get_by_id_getter_proto); + vPC[6] = offset; + break; + case PropertySlot::Custom: + vPC[0] = getOpcode(op_get_by_id_custom_proto); + vPC[6] = slot.customGetter(); + break; + default: + vPC[0] = getOpcode(op_get_by_id_proto); + vPC[6] = offset; + break; + } vPC[5] = baseObject->structure(); - vPC[6] = slot.cachedOffset(); codeBlock->refStructures(vPC); return; } - size_t count = countPrototypeChainEntriesAndCheckForProxies(callFrame, baseValue, slot); + size_t offset = slot.cachedOffset(); + size_t count = normalizePrototypeChain(callFrame, baseValue, slot.slotBase(), propertyName, offset); if (!count) { vPC[0] = getOpcode(op_get_by_id_generic); return; } - vPC[0] = getOpcode(op_get_by_id_chain); + + switch (slot.cachedPropertyType()) { + case PropertySlot::Getter: + vPC[0] = getOpcode(op_get_by_id_getter_chain); + vPC[7] = offset; + break; + case PropertySlot::Custom: + vPC[0] = getOpcode(op_get_by_id_custom_chain); + vPC[7] = slot.customGetter(); + break; + default: + vPC[0] = getOpcode(op_get_by_id_chain); + vPC[7] = offset; + break; + } vPC[4] = structure; vPC[5] = structure->prototypeChain(callFrame); vPC[6] = count; - vPC[7] = slot.cachedOffset(); codeBlock->refStructures(vPC); } @@ -1361,40 +1259,49 @@ NEVER_INLINE void Interpreter::uncacheGetByID(CodeBlock* codeBlock, Instruction* vPC[4] = 0; } -JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValuePtr* exception) +#endif // ENABLE(INTERPRETER) + +JSValue Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValue* exception) { // One-time initialization of our address tables. We have to put this code // here because our labels are only in scope inside this function. - if (flag == InitializeAndReturn) { - #if HAVE(COMPUTED_GOTO) - #define ADD_BYTECODE(id, length) m_opcodeTable[id] = &&id; - FOR_EACH_OPCODE_ID(ADD_BYTECODE); - #undef ADD_BYTECODE - - #define ADD_OPCODE_ID(id, length) m_opcodeIDTable.add(&&id, id); - FOR_EACH_OPCODE_ID(ADD_OPCODE_ID); - #undef ADD_OPCODE_ID - ASSERT(m_opcodeIDTable.size() == numOpcodeIDs); - #endif // HAVE(COMPUTED_GOTO) - return noValue(); + if (UNLIKELY(flag == InitializeAndReturn)) { + #if ENABLE(COMPUTED_GOTO_INTERPRETER) + #define LIST_OPCODE_LABEL(id, length) &&id, + static Opcode labels[] = { FOR_EACH_OPCODE_ID(LIST_OPCODE_LABEL) }; + for (size_t i = 0; i < sizeof(labels) / sizeof(Opcode); ++i) + m_opcodeTable[i] = labels[i]; + #undef LIST_OPCODE_LABEL + #endif // ENABLE(COMPUTED_GOTO_INTERPRETER) + return JSValue(); } - + #if ENABLE(JIT) - // Currently with CTI enabled we never interpret functions - ASSERT_NOT_REACHED(); +#if ENABLE(INTERPRETER) + // Mixing Interpreter + JIT is not supported. + if (callFrame->globalData().canUseJIT()) +#endif + ASSERT_NOT_REACHED(); #endif +#if !ENABLE(INTERPRETER) + UNUSED_PARAM(registerFile); + UNUSED_PARAM(callFrame); + UNUSED_PARAM(exception); + return JSValue(); +#else + JSGlobalData* globalData = &callFrame->globalData(); - JSValuePtr exceptionValue = noValue(); + JSValue exceptionValue; HandlerInfo* handler = 0; Instruction* vPC = callFrame->codeBlock()->instructions().begin(); Profiler** enabledProfilerReference = Profiler::enabledProfilerReference(); - unsigned tickCount = m_ticksUntilNextTimeoutCheck + 1; + unsigned tickCount = globalData->timeoutChecker.ticksUntilNextCheck(); #define CHECK_FOR_EXCEPTION() \ do { \ - if (UNLIKELY(globalData->exception != noValue())) { \ + if (UNLIKELY(globalData->exception != JSValue())) { \ exceptionValue = globalData->exception; \ goto vm_throw; \ } \ @@ -1406,22 +1313,20 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe #define CHECK_FOR_TIMEOUT() \ if (!--tickCount) { \ - if (checkTimeout(callFrame->dynamicGlobalObject())) { \ + if (globalData->terminator.shouldTerminate() || globalData->timeoutChecker.didTimeOut(callFrame)) { \ exceptionValue = jsNull(); \ goto vm_throw; \ } \ - tickCount = m_ticksUntilNextTimeoutCheck; \ + tickCount = globalData->timeoutChecker.ticksUntilNextCheck(); \ } #if ENABLE(OPCODE_SAMPLING) #define SAMPLE(codeBlock, vPC) m_sampler->sample(codeBlock, vPC) - #define CTI_SAMPLER ARG_globalData->interpreter->sampler() #else #define SAMPLE(codeBlock, vPC) - #define CTI_SAMPLER 0 #endif -#if HAVE(COMPUTED_GOTO) +#if ENABLE(COMPUTED_GOTO_INTERPRETER) #define NEXT_INSTRUCTION() SAMPLE(callFrame->codeBlock(), vPC); goto *vPC->u.opcode #if ENABLE(OPCODE_STATS) #define DEFINE_OPCODE(opcode) opcode: OpcodeStats::recordInstruction(opcode); @@ -1447,10 +1352,10 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Constructs a new empty Object instance using the original constructor, and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - callFrame[dst] = JSValuePtr(constructEmptyObject(callFrame)); + int dst = vPC[1].u.operand; + callFrame->r(dst) = JSValue(constructEmptyObject(callFrame)); - ++vPC; + vPC += OPCODE_LENGTH(op_new_object); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_new_array) { @@ -1461,13 +1366,13 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe The array will contain argCount elements with values taken from registers starting at register firstArg. */ - int dst = (++vPC)->u.operand; - int firstArg = (++vPC)->u.operand; - int argCount = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int firstArg = vPC[2].u.operand; + int argCount = vPC[3].u.operand; ArgList args(callFrame->registers() + firstArg, argCount); - callFrame[dst] = JSValuePtr(constructArray(callFrame, args)); + callFrame->r(dst) = JSValue(constructArray(callFrame, args)); - ++vPC; + vPC += OPCODE_LENGTH(op_new_array); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_new_regexp) { @@ -1477,11 +1382,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe constructor from regexp regExp, and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int regExp = (++vPC)->u.operand; - callFrame[dst] = JSValuePtr(new (globalData) RegExpObject(callFrame->scopeChain()->globalObject()->regExpStructure(), callFrame->codeBlock()->regexp(regExp))); + int dst = vPC[1].u.operand; + int regExp = vPC[2].u.operand; + callFrame->r(dst) = JSValue(new (globalData) RegExpObject(callFrame->scopeChain()->globalObject->regExpStructure(), callFrame->codeBlock()->regexp(regExp))); - ++vPC; + vPC += OPCODE_LENGTH(op_new_regexp); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_mov) { @@ -1489,11 +1394,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Copies register src to register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = callFrame[src]; + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + callFrame->r(dst) = callFrame->r(src); - ++vPC; + vPC += OPCODE_LENGTH(op_mov); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_eq) { @@ -1503,18 +1408,18 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe as with the ECMAScript '==' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - if (JSFastMath::canDoFastBitwiseOperations(src1, src2)) - callFrame[dst] = JSFastMath::equal(src1, src2); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32()) + callFrame->r(dst) = jsBoolean(src1.asInt32() == src2.asInt32()); else { - JSValuePtr result = jsBoolean(JSValuePtr::equalSlowCase(callFrame, src1, src2)); + JSValue result = jsBoolean(JSValue::equalSlowCase(callFrame, src1, src2)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_eq); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_eq_null) { @@ -1523,17 +1428,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Checks whether register src is null, as with the ECMAScript '!=' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame); + int dst = vPC[1].u.operand; + JSValue src = callFrame->r(vPC[2].u.operand).jsValue(); if (src.isUndefinedOrNull()) { - callFrame[dst] = jsBoolean(true); - ++vPC; + callFrame->r(dst) = jsBoolean(true); + vPC += OPCODE_LENGTH(op_eq_null); NEXT_INSTRUCTION(); } - callFrame[dst] = jsBoolean(src.isCell() && src.asCell()->structure()->typeInfo().masqueradesAsUndefined()); - ++vPC; + callFrame->r(dst) = jsBoolean(src.isCell() && src.asCell()->structure()->typeInfo().masqueradesAsUndefined()); + vPC += OPCODE_LENGTH(op_eq_null); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_neq) { @@ -1543,18 +1448,18 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe equal, as with the ECMAScript '!=' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - if (JSFastMath::canDoFastBitwiseOperations(src1, src2)) - callFrame[dst] = JSFastMath::notEqual(src1, src2); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32()) + callFrame->r(dst) = jsBoolean(src1.asInt32() != src2.asInt32()); else { - JSValuePtr result = jsBoolean(!JSValuePtr::equalSlowCase(callFrame, src1, src2)); + JSValue result = jsBoolean(!JSValue::equalSlowCase(callFrame, src1, src2)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_neq); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_neq_null) { @@ -1563,17 +1468,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Checks whether register src is not null, as with the ECMAScript '!=' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame); + int dst = vPC[1].u.operand; + JSValue src = callFrame->r(vPC[2].u.operand).jsValue(); if (src.isUndefinedOrNull()) { - callFrame[dst] = jsBoolean(false); - ++vPC; + callFrame->r(dst) = jsBoolean(false); + vPC += OPCODE_LENGTH(op_neq_null); NEXT_INSTRUCTION(); } - callFrame[dst] = jsBoolean(!src.isCell() || !asCell(src)->structure()->typeInfo().masqueradesAsUndefined()); - ++vPC; + callFrame->r(dst) = jsBoolean(!src.isCell() || !asCell(src)->structure()->typeInfo().masqueradesAsUndefined()); + vPC += OPCODE_LENGTH(op_neq_null); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_stricteq) { @@ -1583,12 +1488,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe equal, as with the ECMAScript '===' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - callFrame[dst] = jsBoolean(JSValuePtr::strictEqual(src1, src2)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + bool result = JSValue::strictEqual(callFrame, src1, src2); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = jsBoolean(result); - ++vPC; + vPC += OPCODE_LENGTH(op_stricteq); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_nstricteq) { @@ -1598,12 +1505,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe strictly equal, as with the ECMAScript '!==' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - callFrame[dst] = jsBoolean(!JSValuePtr::strictEqual(src1, src2)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + bool result = !JSValue::strictEqual(callFrame, src1, src2); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = jsBoolean(result); - ++vPC; + vPC += OPCODE_LENGTH(op_nstricteq); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_less) { @@ -1613,14 +1522,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe with the ECMAScript '<' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr result = jsBoolean(jsLess(callFrame, src1, src2)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + JSValue result = jsBoolean(jsLess(callFrame, src1, src2)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; - ++vPC; + vPC += OPCODE_LENGTH(op_less); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_lesseq) { @@ -1630,14 +1539,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe register src2, as with the ECMAScript '<=' operator, and puts the result as a boolean in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr result = jsBoolean(jsLessEq(callFrame, src1, src2)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + JSValue result = jsBoolean(jsLessEq(callFrame, src1, src2)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; - ++vPC; + vPC += OPCODE_LENGTH(op_lesseq); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_pre_inc) { @@ -1646,17 +1555,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Converts register srcDst to number, adds one, and puts the result back in register srcDst. */ - int srcDst = (++vPC)->u.operand; - JSValuePtr v = callFrame[srcDst].jsValue(callFrame); - if (JSFastMath::canDoFastAdditiveOperations(v)) - callFrame[srcDst] = JSValuePtr(JSFastMath::incImmediateNumber(v)); + int srcDst = vPC[1].u.operand; + JSValue v = callFrame->r(srcDst).jsValue(); + if (v.isInt32() && v.asInt32() < INT_MAX) + callFrame->r(srcDst) = jsNumber(callFrame, v.asInt32() + 1); else { - JSValuePtr result = jsNumber(callFrame, v.toNumber(callFrame) + 1); + JSValue result = jsNumber(callFrame, v.toNumber(callFrame) + 1); CHECK_FOR_EXCEPTION(); - callFrame[srcDst] = result; + callFrame->r(srcDst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_pre_inc); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_pre_dec) { @@ -1665,17 +1574,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Converts register srcDst to number, subtracts one, and puts the result back in register srcDst. */ - int srcDst = (++vPC)->u.operand; - JSValuePtr v = callFrame[srcDst].jsValue(callFrame); - if (JSFastMath::canDoFastAdditiveOperations(v)) - callFrame[srcDst] = JSValuePtr(JSFastMath::decImmediateNumber(v)); + int srcDst = vPC[1].u.operand; + JSValue v = callFrame->r(srcDst).jsValue(); + if (v.isInt32() && v.asInt32() > INT_MIN) + callFrame->r(srcDst) = jsNumber(callFrame, v.asInt32() - 1); else { - JSValuePtr result = jsNumber(callFrame, v.toNumber(callFrame) - 1); + JSValue result = jsNumber(callFrame, v.toNumber(callFrame) - 1); CHECK_FOR_EXCEPTION(); - callFrame[srcDst] = result; + callFrame->r(srcDst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_pre_dec); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_post_inc) { @@ -1685,20 +1594,20 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe written to register dst, and the number plus one is written back to register srcDst. */ - int dst = (++vPC)->u.operand; - int srcDst = (++vPC)->u.operand; - JSValuePtr v = callFrame[srcDst].jsValue(callFrame); - if (JSFastMath::canDoFastAdditiveOperations(v)) { - callFrame[dst] = v; - callFrame[srcDst] = JSValuePtr(JSFastMath::incImmediateNumber(v)); + int dst = vPC[1].u.operand; + int srcDst = vPC[2].u.operand; + JSValue v = callFrame->r(srcDst).jsValue(); + if (v.isInt32() && v.asInt32() < INT_MAX) { + callFrame->r(srcDst) = jsNumber(callFrame, v.asInt32() + 1); + callFrame->r(dst) = v; } else { - JSValuePtr number = callFrame[srcDst].jsValue(callFrame).toJSNumber(callFrame); + JSValue number = callFrame->r(srcDst).jsValue().toJSNumber(callFrame); CHECK_FOR_EXCEPTION(); - callFrame[dst] = number; - callFrame[srcDst] = JSValuePtr(jsNumber(callFrame, number.uncheckedGetNumber() + 1)); + callFrame->r(srcDst) = jsNumber(callFrame, number.uncheckedGetNumber() + 1); + callFrame->r(dst) = number; } - ++vPC; + vPC += OPCODE_LENGTH(op_post_inc); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_post_dec) { @@ -1708,20 +1617,20 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe written to register dst, and the number minus one is written back to register srcDst. */ - int dst = (++vPC)->u.operand; - int srcDst = (++vPC)->u.operand; - JSValuePtr v = callFrame[srcDst].jsValue(callFrame); - if (JSFastMath::canDoFastAdditiveOperations(v)) { - callFrame[dst] = v; - callFrame[srcDst] = JSValuePtr(JSFastMath::decImmediateNumber(v)); + int dst = vPC[1].u.operand; + int srcDst = vPC[2].u.operand; + JSValue v = callFrame->r(srcDst).jsValue(); + if (v.isInt32() && v.asInt32() > INT_MIN) { + callFrame->r(srcDst) = jsNumber(callFrame, v.asInt32() - 1); + callFrame->r(dst) = v; } else { - JSValuePtr number = callFrame[srcDst].jsValue(callFrame).toJSNumber(callFrame); + JSValue number = callFrame->r(srcDst).jsValue().toJSNumber(callFrame); CHECK_FOR_EXCEPTION(); - callFrame[dst] = number; - callFrame[srcDst] = JSValuePtr(jsNumber(callFrame, number.uncheckedGetNumber() - 1)); + callFrame->r(srcDst) = jsNumber(callFrame, number.uncheckedGetNumber() - 1); + callFrame->r(dst) = number; } - ++vPC; + vPC += OPCODE_LENGTH(op_post_dec); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_to_jsnumber) { @@ -1730,20 +1639,20 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Converts register src to number, and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; - JSValuePtr srcVal = callFrame[src].jsValue(callFrame); + JSValue srcVal = callFrame->r(src).jsValue(); if (LIKELY(srcVal.isNumber())) - callFrame[dst] = callFrame[src]; + callFrame->r(dst) = callFrame->r(src); else { - JSValuePtr result = srcVal.toJSNumber(callFrame); + JSValue result = srcVal.toJSNumber(callFrame); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_to_jsnumber); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_negate) { @@ -1752,18 +1661,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Converts register src to number, negates it, and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame); - ++vPC; - double v; - if (src.getNumber(v)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, -v)); + int dst = vPC[1].u.operand; + JSValue src = callFrame->r(vPC[2].u.operand).jsValue(); + if (src.isInt32() && (src.asInt32() & 0x7fffffff)) // non-zero and no overflow + callFrame->r(dst) = jsNumber(callFrame, -src.asInt32()); else { - JSValuePtr result = jsNumber(callFrame, -src.toNumber(callFrame)); + JSValue result = jsNumber(callFrame, -src.toNumber(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } + vPC += OPCODE_LENGTH(op_negate); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_add) { @@ -1773,17 +1681,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe in register dst. (JS add may be string concatenation or numeric add, depending on the types of the operands.) */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - if (JSFastMath::canDoFastAdditiveOperations(src1, src2)) - callFrame[dst] = JSValuePtr(JSFastMath::addImmediateNumbers(src1, src2)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32() && !(src1.asInt32() | (src2.asInt32() & 0xc0000000))) // no overflow + callFrame->r(dst) = jsNumber(callFrame, src1.asInt32() + src2.asInt32()); else { - JSValuePtr result = jsAdd(callFrame, src1, src2); + JSValue result = jsAdd(callFrame, src1, src2); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - vPC += 2; + vPC += OPCODE_LENGTH(op_add); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_mul) { @@ -1792,27 +1700,18 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Multiplies register src1 and register src2 (converted to numbers), and puts the product in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - double left; - double right; - if (JSValuePtr::areBothInt32Fast(src1, src2)) { - int32_t left = src1.getInt32Fast(); - int32_t right = src2.getInt32Fast(); - if ((left | right) >> 15 == 0) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left * right)); - else - callFrame[dst] = JSValuePtr(jsNumber(callFrame, static_cast(left) * static_cast(right))); - } else if (src1.getNumber(left) && src2.getNumber(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left * right)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32() && !(src1.asInt32() | src2.asInt32() >> 15)) // no overflow + callFrame->r(dst) = jsNumber(callFrame, src1.asInt32() * src2.asInt32()); else { - JSValuePtr result = jsNumber(callFrame, src1.toNumber(callFrame) * src2.toNumber(callFrame)); + JSValue result = jsNumber(callFrame, src1.toNumber(callFrame) * src2.toNumber(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - vPC += 2; + vPC += OPCODE_LENGTH(op_mul); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_div) { @@ -1822,19 +1721,15 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe register divisor (converted to number), and puts the quotient in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr dividend = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr divisor = callFrame[(++vPC)->u.operand].jsValue(callFrame); - double left; - double right; - if (dividend.getNumber(left) && divisor.getNumber(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left / right)); - else { - JSValuePtr result = jsNumber(callFrame, dividend.toNumber(callFrame) / divisor.toNumber(callFrame)); - CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; - } - ++vPC; + int dst = vPC[1].u.operand; + JSValue dividend = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue divisor = callFrame->r(vPC[3].u.operand).jsValue(); + + JSValue result = jsNumber(callFrame, dividend.toNumber(callFrame) / divisor.toNumber(callFrame)); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + + vPC += OPCODE_LENGTH(op_div); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_mod) { @@ -1844,28 +1739,26 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe register divisor (converted to number), and puts the remainder in register dst. */ - int dst = (++vPC)->u.operand; - int dividend = (++vPC)->u.operand; - int divisor = (++vPC)->u.operand; - - JSValuePtr dividendValue = callFrame[dividend].jsValue(callFrame); - JSValuePtr divisorValue = callFrame[divisor].jsValue(callFrame); + int dst = vPC[1].u.operand; + JSValue dividend = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue divisor = callFrame->r(vPC[3].u.operand).jsValue(); - if (JSValuePtr::areBothInt32Fast(dividendValue, divisorValue) && divisorValue != js0()) { - // We expect the result of the modulus of a number that was representable as an int32 to also be representable - // as an int32. - JSValuePtr result = JSValuePtr::makeInt32Fast(dividendValue.getInt32Fast() % divisorValue.getInt32Fast()); + if (dividend.isInt32() && divisor.isInt32() && divisor.asInt32() != 0) { + JSValue result = jsNumber(callFrame, dividend.asInt32() % divisor.asInt32()); ASSERT(result); - callFrame[dst] = result; - ++vPC; + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_mod); NEXT_INSTRUCTION(); } - double d = dividendValue.toNumber(callFrame); - JSValuePtr result = jsNumber(callFrame, fmod(d, divisorValue.toNumber(callFrame))); + // Conversion to double must happen outside the call to fmod since the + // order of argument evaluation is not guaranteed. + double d1 = dividend.toNumber(callFrame); + double d2 = divisor.toNumber(callFrame); + JSValue result = jsNumber(callFrame, fmod(d1, d2)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; - ++vPC; + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_mod); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_sub) { @@ -1875,21 +1768,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe src1 (converted to number), and puts the difference in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - double left; - double right; - if (JSFastMath::canDoFastAdditiveOperations(src1, src2)) - callFrame[dst] = JSValuePtr(JSFastMath::subImmediateNumbers(src1, src2)); - else if (src1.getNumber(left) && src2.getNumber(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left - right)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32() && !(src1.asInt32() | (src2.asInt32() & 0xc0000000))) // no overflow + callFrame->r(dst) = jsNumber(callFrame, src1.asInt32() - src2.asInt32()); else { - JSValuePtr result = jsNumber(callFrame, src1.toNumber(callFrame) - src2.toNumber(callFrame)); + JSValue result = jsNumber(callFrame, src1.toNumber(callFrame) - src2.toNumber(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - vPC += 2; + vPC += OPCODE_LENGTH(op_sub); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_lshift) { @@ -1899,22 +1788,19 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe register shift (converted to uint32), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr val = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr shift = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int32_t left; - uint32_t right; - if (JSValuePtr::areBothInt32Fast(val, shift)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, val.getInt32Fast() << (shift.getInt32Fast() & 0x1f))); - else if (val.numberToInt32(left) && shift.numberToUInt32(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left << (right & 0x1f))); + int dst = vPC[1].u.operand; + JSValue val = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue shift = callFrame->r(vPC[3].u.operand).jsValue(); + + if (val.isInt32() && shift.isInt32()) + callFrame->r(dst) = jsNumber(callFrame, val.asInt32() << (shift.asInt32() & 0x1f)); else { - JSValuePtr result = jsNumber(callFrame, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f)); + JSValue result = jsNumber(callFrame, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_lshift); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_rshift) { @@ -1924,22 +1810,19 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe to int32) by register shift (converted to uint32), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr val = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr shift = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int32_t left; - uint32_t right; - if (JSFastMath::canDoFastRshift(val, shift)) - callFrame[dst] = JSValuePtr(JSFastMath::rightShiftImmediateNumbers(val, shift)); - else if (val.numberToInt32(left) && shift.numberToUInt32(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left >> (right & 0x1f))); + int dst = vPC[1].u.operand; + JSValue val = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue shift = callFrame->r(vPC[3].u.operand).jsValue(); + + if (val.isInt32() && shift.isInt32()) + callFrame->r(dst) = jsNumber(callFrame, val.asInt32() >> (shift.asInt32() & 0x1f)); else { - JSValuePtr result = jsNumber(callFrame, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f)); + JSValue result = jsNumber(callFrame, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_rshift); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_urshift) { @@ -1949,18 +1832,18 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe to uint32) by register shift (converted to uint32), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr val = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr shift = callFrame[(++vPC)->u.operand].jsValue(callFrame); - if (JSFastMath::canDoFastUrshift(val, shift)) - callFrame[dst] = JSValuePtr(JSFastMath::rightShiftImmediateNumbers(val, shift)); + int dst = vPC[1].u.operand; + JSValue val = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue shift = callFrame->r(vPC[3].u.operand).jsValue(); + if (val.isUInt32() && shift.isInt32()) + callFrame->r(dst) = jsNumber(callFrame, val.asInt32() >> (shift.asInt32() & 0x1f)); else { - JSValuePtr result = jsNumber(callFrame, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f)); + JSValue result = jsNumber(callFrame, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_urshift); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_bitand) { @@ -1970,22 +1853,18 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe and register src2 (converted to int32), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int32_t left; - int32_t right; - if (JSFastMath::canDoFastBitwiseOperations(src1, src2)) - callFrame[dst] = JSValuePtr(JSFastMath::andImmediateNumbers(src1, src2)); - else if (src1.numberToInt32(left) && src2.numberToInt32(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left & right)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32()) + callFrame->r(dst) = jsNumber(callFrame, src1.asInt32() & src2.asInt32()); else { - JSValuePtr result = jsNumber(callFrame, src1.toInt32(callFrame) & src2.toInt32(callFrame)); + JSValue result = jsNumber(callFrame, src1.toInt32(callFrame) & src2.toInt32(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - vPC += 2; + vPC += OPCODE_LENGTH(op_bitand); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_bitxor) { @@ -1995,22 +1874,18 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe and register src2 (converted to int32), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int32_t left; - int32_t right; - if (JSFastMath::canDoFastBitwiseOperations(src1, src2)) - callFrame[dst] = JSValuePtr(JSFastMath::xorImmediateNumbers(src1, src2)); - else if (src1.numberToInt32(left) && src2.numberToInt32(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left ^ right)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32()) + callFrame->r(dst) = jsNumber(callFrame, src1.asInt32() ^ src2.asInt32()); else { - JSValuePtr result = jsNumber(callFrame, src1.toInt32(callFrame) ^ src2.toInt32(callFrame)); + JSValue result = jsNumber(callFrame, src1.toInt32(callFrame) ^ src2.toInt32(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - vPC += 2; + vPC += OPCODE_LENGTH(op_bitxor); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_bitor) { @@ -2020,22 +1895,18 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe and register src2 (converted to int32), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int32_t left; - int32_t right; - if (JSFastMath::canDoFastBitwiseOperations(src1, src2)) - callFrame[dst] = JSValuePtr(JSFastMath::orImmediateNumbers(src1, src2)); - else if (src1.numberToInt32(left) && src2.numberToInt32(right)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, left | right)); + int dst = vPC[1].u.operand; + JSValue src1 = callFrame->r(vPC[2].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[3].u.operand).jsValue(); + if (src1.isInt32() && src2.isInt32()) + callFrame->r(dst) = jsNumber(callFrame, src1.asInt32() | src2.asInt32()); else { - JSValuePtr result = jsNumber(callFrame, src1.toInt32(callFrame) | src2.toInt32(callFrame)); + JSValue result = jsNumber(callFrame, src1.toInt32(callFrame) | src2.toInt32(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - vPC += 2; + vPC += OPCODE_LENGTH(op_bitor); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_bitnot) { @@ -2044,17 +1915,16 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Computes bitwise NOT of register src1 (converted to int32), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int32_t value; - if (src.numberToInt32(value)) - callFrame[dst] = JSValuePtr(jsNumber(callFrame, ~value)); + int dst = vPC[1].u.operand; + JSValue src = callFrame->r(vPC[2].u.operand).jsValue(); + if (src.isInt32()) + callFrame->r(dst) = jsNumber(callFrame, ~src.asInt32()); else { - JSValuePtr result = jsNumber(callFrame, ~src.toInt32(callFrame)); + JSValue result = jsNumber(callFrame, ~src.toInt32(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; } - ++vPC; + vPC += OPCODE_LENGTH(op_bitnot); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_not) { @@ -2063,13 +1933,13 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Computes logical NOT of register src (converted to boolean), and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - JSValuePtr result = jsBoolean(!callFrame[src].jsValue(callFrame).toBoolean(callFrame)); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + JSValue result = jsBoolean(!callFrame->r(src).jsValue().toBoolean(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; + callFrame->r(dst) = result; - ++vPC; + vPC += OPCODE_LENGTH(op_not); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_instanceof) { @@ -2090,15 +1960,16 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int base = vPC[3].u.operand; int baseProto = vPC[4].u.operand; - JSValuePtr baseVal = callFrame[base].jsValue(callFrame); + JSValue baseVal = callFrame->r(base).jsValue(); - if (isNotObject(callFrame, true, callFrame->codeBlock(), vPC, baseVal, exceptionValue)) + if (isInvalidParamForInstanceOf(callFrame, callFrame->codeBlock(), vPC, baseVal, exceptionValue)) goto vm_throw; - JSObject* baseObj = asObject(baseVal); - callFrame[dst] = jsBoolean(baseObj->structure()->typeInfo().implementsHasInstance() ? baseObj->hasInstance(callFrame, callFrame[value].jsValue(callFrame), callFrame[baseProto].jsValue(callFrame)) : false); + bool result = asObject(baseVal)->hasInstance(callFrame, callFrame->r(value).jsValue(), callFrame->r(baseProto).jsValue()); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = jsBoolean(result); - vPC += 5; + vPC += OPCODE_LENGTH(op_instanceof); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_typeof) { @@ -2107,11 +1978,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Determines the type string for src according to ECMAScript rules, and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = JSValuePtr(jsTypeStringForValue(callFrame, callFrame[src].jsValue(callFrame))); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + callFrame->r(dst) = JSValue(jsTypeStringForValue(callFrame, callFrame->r(src).jsValue())); - ++vPC; + vPC += OPCODE_LENGTH(op_typeof); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_is_undefined) { @@ -2121,12 +1992,12 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the ECMAScript rules is "undefined", and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - JSValuePtr v = callFrame[src].jsValue(callFrame); - callFrame[dst] = jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined()); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + JSValue v = callFrame->r(src).jsValue(); + callFrame->r(dst) = jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined()); - ++vPC; + vPC += OPCODE_LENGTH(op_is_undefined); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_is_boolean) { @@ -2136,11 +2007,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the ECMAScript rules is "boolean", and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame).isBoolean()); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + callFrame->r(dst) = jsBoolean(callFrame->r(src).jsValue().isBoolean()); - ++vPC; + vPC += OPCODE_LENGTH(op_is_boolean); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_is_number) { @@ -2150,11 +2021,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the ECMAScript rules is "number", and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame).isNumber()); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + callFrame->r(dst) = jsBoolean(callFrame->r(src).jsValue().isNumber()); - ++vPC; + vPC += OPCODE_LENGTH(op_is_number); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_is_string) { @@ -2164,11 +2035,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the ECMAScript rules is "string", and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame).isString()); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + callFrame->r(dst) = jsBoolean(callFrame->r(src).jsValue().isString()); - ++vPC; + vPC += OPCODE_LENGTH(op_is_string); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_is_object) { @@ -2178,11 +2049,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the ECMAScript rules is "object", and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = jsBoolean(jsIsObjectType(callFrame[src].jsValue(callFrame))); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + callFrame->r(dst) = jsBoolean(jsIsObjectType(callFrame->r(src).jsValue())); - ++vPC; + vPC += OPCODE_LENGTH(op_is_object); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_is_function) { @@ -2192,11 +2063,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the ECMAScript rules is "function", and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = jsBoolean(jsIsFunctionType(callFrame[src].jsValue(callFrame))); + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + callFrame->r(dst) = jsBoolean(jsIsFunctionType(callFrame->r(src).jsValue())); - ++vPC; + vPC += OPCODE_LENGTH(op_is_function); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_in) { @@ -2208,28 +2079,28 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Raises an exception if register constructor is not an object. */ - int dst = (++vPC)->u.operand; - int property = (++vPC)->u.operand; - int base = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int property = vPC[2].u.operand; + int base = vPC[3].u.operand; - JSValuePtr baseVal = callFrame[base].jsValue(callFrame); - if (isNotObject(callFrame, false, callFrame->codeBlock(), vPC, baseVal, exceptionValue)) + JSValue baseVal = callFrame->r(base).jsValue(); + if (isInvalidParamForIn(callFrame, callFrame->codeBlock(), vPC, baseVal, exceptionValue)) goto vm_throw; JSObject* baseObj = asObject(baseVal); - JSValuePtr propName = callFrame[property].jsValue(callFrame); + JSValue propName = callFrame->r(property).jsValue(); uint32_t i; if (propName.getUInt32(i)) - callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, i)); + callFrame->r(dst) = jsBoolean(baseObj->hasProperty(callFrame, i)); else { Identifier property(callFrame, propName.toString(callFrame)); CHECK_FOR_EXCEPTION(); - callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, property)); + callFrame->r(dst) = jsBoolean(baseObj->hasProperty(callFrame, property)); } - ++vPC; + vPC += OPCODE_LENGTH(op_in); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_resolve) { @@ -2242,7 +2113,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe if (UNLIKELY(!resolve(callFrame, vPC, exceptionValue))) goto vm_throw; - vPC += 3; + vPC += OPCODE_LENGTH(op_resolve); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_resolve_skip) { @@ -2255,7 +2126,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe if (UNLIKELY(!resolveSkip(callFrame, vPC, exceptionValue))) goto vm_throw; - vPC += 4; + vPC += OPCODE_LENGTH(op_resolve_skip); NEXT_INSTRUCTION(); } @@ -2270,7 +2141,25 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe if (UNLIKELY(!resolveGlobal(callFrame, vPC, exceptionValue))) goto vm_throw; - vPC += 6; + vPC += OPCODE_LENGTH(op_resolve_global); + + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_resolve_global_dynamic) { + /* resolve_skip dst(r) globalObject(c) property(id) structure(sID) offset(n), depth(n) + + Performs a dynamic property lookup for the given property, on the provided + global object. If structure matches the Structure of the global then perform + a fast lookup using the case offset, otherwise fall back to a full resolve and + cache the new structure and offset. + + This walks through n levels of the scope chain to verify that none of those levels + in the scope chain include dynamically added properties. + */ + if (UNLIKELY(!resolveGlobalDynamic(callFrame, vPC, exceptionValue))) + goto vm_throw; + + vPC += OPCODE_LENGTH(op_resolve_global_dynamic); NEXT_INSTRUCTION(); } @@ -2279,13 +2168,13 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Gets the global var at global slot index and places it in register dst. */ - int dst = (++vPC)->u.operand; - JSGlobalObject* scope = static_cast((++vPC)->u.jsCell); + int dst = vPC[1].u.operand; + JSGlobalObject* scope = static_cast(vPC[2].u.jsCell); ASSERT(scope->isGlobalObject()); - int index = (++vPC)->u.operand; + int index = vPC[3].u.operand; - callFrame[dst] = scope->registerAt(index); - ++vPC; + callFrame->r(dst) = scope->registerAt(index); + vPC += OPCODE_LENGTH(op_get_global_var); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_global_var) { @@ -2293,24 +2182,24 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Puts value into global slot index. */ - JSGlobalObject* scope = static_cast((++vPC)->u.jsCell); + JSGlobalObject* scope = static_cast(vPC[1].u.jsCell); ASSERT(scope->isGlobalObject()); - int index = (++vPC)->u.operand; - int value = (++vPC)->u.operand; + int index = vPC[2].u.operand; + int value = vPC[3].u.operand; - scope->registerAt(index) = JSValuePtr(callFrame[value].jsValue(callFrame)); - ++vPC; + scope->registerAt(index) = JSValue(callFrame->r(value).jsValue()); + vPC += OPCODE_LENGTH(op_put_global_var); NEXT_INSTRUCTION(); - } + } DEFINE_OPCODE(op_get_scoped_var) { /* get_scoped_var dst(r) index(n) skip(n) Loads the contents of the index-th local from the scope skip nodes from the top of the scope chain, and places it in register dst */ - int dst = (++vPC)->u.operand; - int index = (++vPC)->u.operand; - int skip = (++vPC)->u.operand + callFrame->codeBlock()->needsFullScopeChain(); + int dst = vPC[1].u.operand; + int index = vPC[2].u.operand; + int skip = vPC[3].u.operand + callFrame->codeBlock()->needsFullScopeChain(); ScopeChainNode* scopeChain = callFrame->scopeChain(); ScopeChainIterator iter = scopeChain->begin(); @@ -2320,20 +2209,19 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe ++iter; ASSERT(iter != end); } - ASSERT((*iter)->isVariableObject()); JSVariableObject* scope = static_cast(*iter); - callFrame[dst] = scope->registerAt(index); - ++vPC; + callFrame->r(dst) = scope->registerAt(index); + vPC += OPCODE_LENGTH(op_get_scoped_var); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_scoped_var) { /* put_scoped_var index(n) skip(n) value(r) */ - int index = (++vPC)->u.operand; - int skip = (++vPC)->u.operand + callFrame->codeBlock()->needsFullScopeChain(); - int value = (++vPC)->u.operand; + int index = vPC[1].u.operand; + int skip = vPC[2].u.operand + callFrame->codeBlock()->needsFullScopeChain(); + int value = vPC[3].u.operand; ScopeChainNode* scopeChain = callFrame->scopeChain(); ScopeChainIterator iter = scopeChain->begin(); @@ -2346,8 +2234,8 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe ASSERT((*iter)->isVariableObject()); JSVariableObject* scope = static_cast(*iter); - scope->registerAt(index) = JSValuePtr(callFrame[value].jsValue(callFrame)); - ++vPC; + scope->registerAt(index) = JSValue(callFrame->r(value).jsValue()); + vPC += OPCODE_LENGTH(op_put_scoped_var); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_resolve_base) { @@ -2360,7 +2248,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe */ resolveBase(callFrame, vPC); - vPC += 3; + vPC += OPCODE_LENGTH(op_resolve_base); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_resolve_with_base) { @@ -2378,28 +2266,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe if (UNLIKELY(!resolveBaseAndProperty(callFrame, vPC, exceptionValue))) goto vm_throw; - vPC += 4; - NEXT_INSTRUCTION(); - } - DEFINE_OPCODE(op_resolve_func) { - /* resolve_func baseDst(r) funcDst(r) property(id) - - Searches the scope chain for an object containing - identifier property, and if one is found, writes the - appropriate object to use as "this" when calling its - properties to register baseDst; and the retrieved property - value to register propDst. If the property is not found, - raises an exception. - - This differs from resolve_with_base, because the - global this value will be substituted for activations or - the global object, which is the right behavior for function - calls but not for other property lookup. - */ - if (UNLIKELY(!resolveBaseAndFunc(callFrame, vPC, exceptionValue))) - goto vm_throw; - - vPC += 4; + vPC += OPCODE_LENGTH(op_resolve_with_base); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_get_by_id) { @@ -2414,15 +2281,15 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe CodeBlock* codeBlock = callFrame->codeBlock(); Identifier& ident = codeBlock->identifier(property); - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(callFrame, ident, slot); + JSValue result = baseValue.get(callFrame, ident, slot); CHECK_FOR_EXCEPTION(); tryCacheGetByID(callFrame, codeBlock, vPC, baseValue, ident, slot); - callFrame[dst] = result; - vPC += 8; + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_get_by_id); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_get_by_id_self) { @@ -2433,7 +2300,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe op_get_by_id. */ int base = vPC[2].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); if (LIKELY(baseValue.isCell())) { JSCell* baseCell = asCell(baseValue); @@ -2446,9 +2313,9 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int offset = vPC[5].u.operand; ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == baseObject->getDirectOffset(offset)); - callFrame[dst] = JSValuePtr(baseObject->getDirectOffset(offset)); + callFrame->r(dst) = JSValue(baseObject->getDirectOffset(offset)); - vPC += 8; + vPC += OPCODE_LENGTH(op_get_by_id_self); NEXT_INSTRUCTION(); } } @@ -2464,7 +2331,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe reverts to op_get_by_id. */ int base = vPC[2].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); if (LIKELY(baseValue.isCell())) { JSCell* baseCell = asCell(baseValue); @@ -2480,9 +2347,10 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int offset = vPC[6].u.operand; ASSERT(protoObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == protoObject->getDirectOffset(offset)); - callFrame[dst] = JSValuePtr(protoObject->getDirectOffset(offset)); + ASSERT(baseValue.get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == protoObject->getDirectOffset(offset)); + callFrame->r(dst) = JSValue(protoObject->getDirectOffset(offset)); - vPC += 8; + vPC += OPCODE_LENGTH(op_get_by_id_proto); NEXT_INSTRUCTION(); } } @@ -2491,53 +2359,169 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe uncacheGetByID(callFrame->codeBlock(), vPC); NEXT_INSTRUCTION(); } - DEFINE_OPCODE(op_get_by_id_self_list) { - // Polymorphic self access caching currently only supported when JITting. - ASSERT_NOT_REACHED(); - // This case of the switch must not be empty, else (op_get_by_id_self_list == op_get_by_id_chain)! - vPC += 8; - NEXT_INSTRUCTION(); - } - DEFINE_OPCODE(op_get_by_id_proto_list) { - // Polymorphic prototype access caching currently only supported when JITting. - ASSERT_NOT_REACHED(); - // This case of the switch must not be empty, else (op_get_by_id_proto_list == op_get_by_id_chain)! - vPC += 8; - NEXT_INSTRUCTION(); - } - DEFINE_OPCODE(op_get_by_id_chain) { - /* op_get_by_id_chain dst(r) base(r) property(id) structure(sID) structureChain(chain) count(n) offset(n) - - Cached property access: Attempts to get a cached property from the - value base's prototype chain. If the cache misses, op_get_by_id_chain - reverts to op_get_by_id. - */ +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + goto *(&&skip_id_getter_proto); +#endif + DEFINE_OPCODE(op_get_by_id_getter_proto) { + /* op_get_by_id_getter_proto dst(r) base(r) property(id) structure(sID) prototypeStructure(sID) offset(n) nop(n) + + Cached property access: Attempts to get a cached getter property from the + value base's prototype. If the cache misses, op_get_by_id_getter_proto + reverts to op_get_by_id. + */ int base = vPC[2].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); - + JSValue baseValue = callFrame->r(base).jsValue(); + if (LIKELY(baseValue.isCell())) { JSCell* baseCell = asCell(baseValue); Structure* structure = vPC[4].u.structure; - + if (LIKELY(baseCell->structure() == structure)) { - RefPtr* it = vPC[5].u.structureChain->head(); - size_t count = vPC[6].u.operand; - RefPtr* end = it + count; - - while (true) { - JSObject* baseObject = asObject(baseCell->structure()->prototypeForLookup(callFrame)); - - if (UNLIKELY(baseObject->structure() != (*it).get())) - break; - - if (++it == end) { - int dst = vPC[1].u.operand; + ASSERT(structure->prototypeForLookup(callFrame).isObject()); + JSObject* protoObject = asObject(structure->prototypeForLookup(callFrame)); + Structure* prototypeStructure = vPC[5].u.structure; + + if (LIKELY(protoObject->structure() == prototypeStructure)) { + int dst = vPC[1].u.operand; + int offset = vPC[6].u.operand; + if (GetterSetter* getterSetter = asGetterSetter(protoObject->getDirectOffset(offset).asCell())) { + JSObject* getter = getterSetter->getter(); + CallData callData; + CallType callType = getter->getCallData(callData); + JSValue result = call(callFrame, getter, callType, callData, asObject(baseCell), ArgList()); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + } else + callFrame->r(dst) = jsUndefined(); + vPC += OPCODE_LENGTH(op_get_by_id_getter_proto); + NEXT_INSTRUCTION(); + } + } + } + uncacheGetByID(callFrame->codeBlock(), vPC); + NEXT_INSTRUCTION(); + } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + skip_id_getter_proto: +#endif +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + goto *(&&skip_id_custom_proto); +#endif + DEFINE_OPCODE(op_get_by_id_custom_proto) { + /* op_get_by_id_custom_proto dst(r) base(r) property(id) structure(sID) prototypeStructure(sID) offset(n) nop(n) + + Cached property access: Attempts to use a cached named property getter + from the value base's prototype. If the cache misses, op_get_by_id_custom_proto + reverts to op_get_by_id. + */ + int base = vPC[2].u.operand; + JSValue baseValue = callFrame->r(base).jsValue(); + + if (LIKELY(baseValue.isCell())) { + JSCell* baseCell = asCell(baseValue); + Structure* structure = vPC[4].u.structure; + + if (LIKELY(baseCell->structure() == structure)) { + ASSERT(structure->prototypeForLookup(callFrame).isObject()); + JSObject* protoObject = asObject(structure->prototypeForLookup(callFrame)); + Structure* prototypeStructure = vPC[5].u.structure; + + if (LIKELY(protoObject->structure() == prototypeStructure)) { + int dst = vPC[1].u.operand; + int property = vPC[3].u.operand; + Identifier& ident = callFrame->codeBlock()->identifier(property); + + PropertySlot::GetValueFunc getter = vPC[6].u.getterFunc; + JSValue result = getter(callFrame, protoObject, ident); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_get_by_id_custom_proto); + NEXT_INSTRUCTION(); + } + } + } + uncacheGetByID(callFrame->codeBlock(), vPC); + NEXT_INSTRUCTION(); + } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + skip_id_custom_proto: +#endif + DEFINE_OPCODE(op_get_by_id_self_list) { + // Polymorphic self access caching currently only supported when JITting. + ASSERT_NOT_REACHED(); + // This case of the switch must not be empty, else (op_get_by_id_self_list == op_get_by_id_chain)! + vPC += OPCODE_LENGTH(op_get_by_id_self_list); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_get_by_id_proto_list) { + // Polymorphic prototype access caching currently only supported when JITting. + ASSERT_NOT_REACHED(); + // This case of the switch must not be empty, else (op_get_by_id_proto_list == op_get_by_id_chain)! + vPC += OPCODE_LENGTH(op_get_by_id_proto_list); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_get_by_id_getter_self_list) { + // Polymorphic self access caching currently only supported when JITting. + ASSERT_NOT_REACHED(); + // This case of the switch must not be empty, else (op_get_by_id_self_list == op_get_by_id_chain)! + vPC += OPCODE_LENGTH(op_get_by_id_self_list); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_get_by_id_getter_proto_list) { + // Polymorphic prototype access caching currently only supported when JITting. + ASSERT_NOT_REACHED(); + // This case of the switch must not be empty, else (op_get_by_id_proto_list == op_get_by_id_chain)! + vPC += OPCODE_LENGTH(op_get_by_id_proto_list); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_get_by_id_custom_self_list) { + // Polymorphic self access caching currently only supported when JITting. + ASSERT_NOT_REACHED(); + // This case of the switch must not be empty, else (op_get_by_id_self_list == op_get_by_id_chain)! + vPC += OPCODE_LENGTH(op_get_by_id_custom_self_list); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_get_by_id_custom_proto_list) { + // Polymorphic prototype access caching currently only supported when JITting. + ASSERT_NOT_REACHED(); + // This case of the switch must not be empty, else (op_get_by_id_proto_list == op_get_by_id_chain)! + vPC += OPCODE_LENGTH(op_get_by_id_proto_list); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_get_by_id_chain) { + /* op_get_by_id_chain dst(r) base(r) property(id) structure(sID) structureChain(chain) count(n) offset(n) + + Cached property access: Attempts to get a cached property from the + value base's prototype chain. If the cache misses, op_get_by_id_chain + reverts to op_get_by_id. + */ + int base = vPC[2].u.operand; + JSValue baseValue = callFrame->r(base).jsValue(); + + if (LIKELY(baseValue.isCell())) { + JSCell* baseCell = asCell(baseValue); + Structure* structure = vPC[4].u.structure; + + if (LIKELY(baseCell->structure() == structure)) { + RefPtr* it = vPC[5].u.structureChain->head(); + size_t count = vPC[6].u.operand; + RefPtr* end = it + count; + + while (true) { + JSObject* baseObject = asObject(baseCell->structure()->prototypeForLookup(callFrame)); + + if (UNLIKELY(baseObject->structure() != (*it).get())) + break; + + if (++it == end) { + int dst = vPC[1].u.operand; int offset = vPC[7].u.operand; ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == baseObject->getDirectOffset(offset)); - callFrame[dst] = JSValuePtr(baseObject->getDirectOffset(offset)); + ASSERT(baseValue.get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == baseObject->getDirectOffset(offset)); + callFrame->r(dst) = JSValue(baseObject->getDirectOffset(offset)); - vPC += 8; + vPC += OPCODE_LENGTH(op_get_by_id_chain); NEXT_INSTRUCTION(); } @@ -2550,6 +2534,86 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe uncacheGetByID(callFrame->codeBlock(), vPC); NEXT_INSTRUCTION(); } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + goto *(&&skip_id_getter_self); +#endif + DEFINE_OPCODE(op_get_by_id_getter_self) { + /* op_get_by_id_self dst(r) base(r) property(id) structure(sID) offset(n) nop(n) nop(n) + + Cached property access: Attempts to get a cached property from the + value base. If the cache misses, op_get_by_id_getter_self reverts to + op_get_by_id. + */ + int base = vPC[2].u.operand; + JSValue baseValue = callFrame->r(base).jsValue(); + + if (LIKELY(baseValue.isCell())) { + JSCell* baseCell = asCell(baseValue); + Structure* structure = vPC[4].u.structure; + + if (LIKELY(baseCell->structure() == structure)) { + ASSERT(baseCell->isObject()); + JSObject* baseObject = asObject(baseCell); + int dst = vPC[1].u.operand; + int offset = vPC[5].u.operand; + + if (GetterSetter* getterSetter = asGetterSetter(baseObject->getDirectOffset(offset).asCell())) { + JSObject* getter = getterSetter->getter(); + CallData callData; + CallType callType = getter->getCallData(callData); + JSValue result = call(callFrame, getter, callType, callData, baseObject, ArgList()); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + } else + callFrame->r(dst) = jsUndefined(); + + vPC += OPCODE_LENGTH(op_get_by_id_getter_self); + NEXT_INSTRUCTION(); + } + } + uncacheGetByID(callFrame->codeBlock(), vPC); + NEXT_INSTRUCTION(); + } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + skip_id_getter_self: +#endif +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + goto *(&&skip_id_custom_self); +#endif + DEFINE_OPCODE(op_get_by_id_custom_self) { + /* op_get_by_id_custom_self dst(r) base(r) property(id) structure(sID) offset(n) nop(n) nop(n) + + Cached property access: Attempts to use a cached named property getter + from the value base. If the cache misses, op_get_by_id_custom_self reverts to + op_get_by_id. + */ + int base = vPC[2].u.operand; + JSValue baseValue = callFrame->r(base).jsValue(); + + if (LIKELY(baseValue.isCell())) { + JSCell* baseCell = asCell(baseValue); + Structure* structure = vPC[4].u.structure; + + if (LIKELY(baseCell->structure() == structure)) { + ASSERT(baseCell->isObject()); + int dst = vPC[1].u.operand; + int property = vPC[3].u.operand; + Identifier& ident = callFrame->codeBlock()->identifier(property); + + PropertySlot::GetValueFunc getter = vPC[5].u.getterFunc; + JSValue result = getter(callFrame, baseValue, ident); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_get_by_id_custom_self); + NEXT_INSTRUCTION(); + } + } + uncacheGetByID(callFrame->codeBlock(), vPC); + NEXT_INSTRUCTION(); + } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) +skip_id_custom_self: +#endif DEFINE_OPCODE(op_get_by_id_generic) { /* op_get_by_id_generic dst(r) base(r) property(id) nop(sID) nop(n) nop(n) nop(n) @@ -2561,15 +2625,122 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int property = vPC[3].u.operand; Identifier& ident = callFrame->codeBlock()->identifier(property); - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(callFrame, ident, slot); + JSValue result = baseValue.get(callFrame, ident, slot); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; - vPC += 8; + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_get_by_id_generic); + NEXT_INSTRUCTION(); + } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + goto *(&&skip_id_getter_chain); +#endif + DEFINE_OPCODE(op_get_by_id_getter_chain) { + /* op_get_by_id_getter_chain dst(r) base(r) property(id) structure(sID) structureChain(chain) count(n) offset(n) + + Cached property access: Attempts to get a cached property from the + value base's prototype chain. If the cache misses, op_get_by_id_getter_chain + reverts to op_get_by_id. + */ + int base = vPC[2].u.operand; + JSValue baseValue = callFrame->r(base).jsValue(); + + if (LIKELY(baseValue.isCell())) { + JSCell* baseCell = asCell(baseValue); + Structure* structure = vPC[4].u.structure; + + if (LIKELY(baseCell->structure() == structure)) { + RefPtr* it = vPC[5].u.structureChain->head(); + size_t count = vPC[6].u.operand; + RefPtr* end = it + count; + + while (true) { + JSObject* baseObject = asObject(baseCell->structure()->prototypeForLookup(callFrame)); + + if (UNLIKELY(baseObject->structure() != (*it).get())) + break; + + if (++it == end) { + int dst = vPC[1].u.operand; + int offset = vPC[7].u.operand; + if (GetterSetter* getterSetter = asGetterSetter(baseObject->getDirectOffset(offset).asCell())) { + JSObject* getter = getterSetter->getter(); + CallData callData; + CallType callType = getter->getCallData(callData); + JSValue result = call(callFrame, getter, callType, callData, baseValue, ArgList()); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + } else + callFrame->r(dst) = jsUndefined(); + vPC += OPCODE_LENGTH(op_get_by_id_getter_chain); + NEXT_INSTRUCTION(); + } + + // Update baseCell, so that next time around the loop we'll pick up the prototype's prototype. + baseCell = baseObject; + } + } + } + uncacheGetByID(callFrame->codeBlock(), vPC); + NEXT_INSTRUCTION(); + } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + skip_id_getter_chain: +#endif +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + goto *(&&skip_id_custom_chain); +#endif + DEFINE_OPCODE(op_get_by_id_custom_chain) { + /* op_get_by_id_custom_chain dst(r) base(r) property(id) structure(sID) structureChain(chain) count(n) offset(n) + + Cached property access: Attempts to use a cached named property getter on the + value base's prototype chain. If the cache misses, op_get_by_id_custom_chain + reverts to op_get_by_id. + */ + int base = vPC[2].u.operand; + JSValue baseValue = callFrame->r(base).jsValue(); + + if (LIKELY(baseValue.isCell())) { + JSCell* baseCell = asCell(baseValue); + Structure* structure = vPC[4].u.structure; + + if (LIKELY(baseCell->structure() == structure)) { + RefPtr* it = vPC[5].u.structureChain->head(); + size_t count = vPC[6].u.operand; + RefPtr* end = it + count; + + while (true) { + JSObject* baseObject = asObject(baseCell->structure()->prototypeForLookup(callFrame)); + + if (UNLIKELY(baseObject->structure() != (*it).get())) + break; + + if (++it == end) { + int dst = vPC[1].u.operand; + int property = vPC[3].u.operand; + Identifier& ident = callFrame->codeBlock()->identifier(property); + + PropertySlot::GetValueFunc getter = vPC[7].u.getterFunc; + JSValue result = getter(callFrame, baseObject, ident); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_get_by_id_custom_chain); + NEXT_INSTRUCTION(); + } + + // Update baseCell, so that next time around the loop we'll pick up the prototype's prototype. + baseCell = baseObject; + } + } + } + uncacheGetByID(callFrame->codeBlock(), vPC); NEXT_INSTRUCTION(); } +#if USE(GCC_COMPUTED_GOTO_WORKAROUND) + skip_id_custom_chain: +#endif DEFINE_OPCODE(op_get_array_length) { /* op_get_array_length dst(r) base(r) property(id) nop(sID) nop(n) nop(n) nop(n) @@ -2579,11 +2750,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe */ int base = vPC[2].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); - if (LIKELY(isJSArray(baseValue))) { + JSValue baseValue = callFrame->r(base).jsValue(); + if (LIKELY(isJSArray(globalData, baseValue))) { int dst = vPC[1].u.operand; - callFrame[dst] = JSValuePtr(jsNumber(callFrame, asArray(baseValue)->length())); - vPC += 8; + callFrame->r(dst) = jsNumber(callFrame, asArray(baseValue)->length()); + vPC += OPCODE_LENGTH(op_get_array_length); NEXT_INSTRUCTION(); } @@ -2599,11 +2770,11 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe */ int base = vPC[2].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); - if (LIKELY(isJSString(baseValue))) { + JSValue baseValue = callFrame->r(base).jsValue(); + if (LIKELY(isJSString(globalData, baseValue))) { int dst = vPC[1].u.operand; - callFrame[dst] = JSValuePtr(jsNumber(callFrame, asString(baseValue)->value().size())); - vPC += 8; + callFrame->r(dst) = jsNumber(callFrame, asString(baseValue)->length()); + vPC += OPCODE_LENGTH(op_get_string_length); NEXT_INSTRUCTION(); } @@ -2611,33 +2782,41 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_by_id) { - /* put_by_id base(r) property(id) value(r) nop(n) nop(n) nop(n) nop(n) + /* put_by_id base(r) property(id) value(r) nop(n) nop(n) nop(n) nop(n) direct(b) Generic property access: Sets the property named by identifier property, belonging to register base, to register value. Unlike many opcodes, this one does not write any output to the register file. + + The "direct" flag should only be set this put_by_id is to initialize + an object literal. */ int base = vPC[1].u.operand; int property = vPC[2].u.operand; int value = vPC[3].u.operand; + int direct = vPC[8].u.operand; CodeBlock* codeBlock = callFrame->codeBlock(); - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); Identifier& ident = codeBlock->identifier(property); PutPropertySlot slot; - baseValue.put(callFrame, ident, callFrame[value].jsValue(callFrame), slot); + if (direct) { + baseValue.putDirect(callFrame, ident, callFrame->r(value).jsValue(), slot); + ASSERT(slot.base() == baseValue); + } else + baseValue.put(callFrame, ident, callFrame->r(value).jsValue(), slot); CHECK_FOR_EXCEPTION(); tryCachePutByID(callFrame, codeBlock, vPC, baseValue, slot); - vPC += 8; + vPC += OPCODE_LENGTH(op_put_by_id); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_by_id_transition) { - /* op_put_by_id_transition base(r) property(id) value(r) oldStructure(sID) newStructure(sID) structureChain(chain) offset(n) + /* op_put_by_id_transition base(r) property(id) value(r) oldStructure(sID) newStructure(sID) structureChain(chain) offset(n) direct(b) Cached property access: Attempts to set a new property with a cached transition property named by identifier property, belonging to register base, @@ -2648,7 +2827,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the register file. */ int base = vPC[1].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); if (LIKELY(baseValue.isCell())) { JSCell* baseCell = asCell(baseValue); @@ -2658,27 +2837,29 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe if (LIKELY(baseCell->structure() == oldStructure)) { ASSERT(baseCell->isObject()); JSObject* baseObject = asObject(baseCell); - - RefPtr* it = vPC[6].u.structureChain->head(); - - JSValuePtr proto = baseObject->structure()->prototypeForLookup(callFrame); - while (!proto.isNull()) { - if (UNLIKELY(asObject(proto)->structure() != (*it).get())) { - uncachePutByID(callFrame->codeBlock(), vPC); - NEXT_INSTRUCTION(); + int direct = vPC[8].u.operand; + + if (!direct) { + RefPtr* it = vPC[6].u.structureChain->head(); + + JSValue proto = baseObject->structure()->prototypeForLookup(callFrame); + while (!proto.isNull()) { + if (UNLIKELY(asObject(proto)->structure() != (*it).get())) { + uncachePutByID(callFrame->codeBlock(), vPC); + NEXT_INSTRUCTION(); + } + ++it; + proto = asObject(proto)->structure()->prototypeForLookup(callFrame); } - ++it; - proto = asObject(proto)->structure()->prototypeForLookup(callFrame); } - baseObject->transitionTo(newStructure); int value = vPC[3].u.operand; unsigned offset = vPC[7].u.operand; ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifier(vPC[2].u.operand))) == offset); - baseObject->putDirectOffset(offset, callFrame[value].jsValue(callFrame)); + baseObject->putDirectOffset(offset, callFrame->r(value).jsValue()); - vPC += 8; + vPC += OPCODE_LENGTH(op_put_by_id_transition); NEXT_INSTRUCTION(); } } @@ -2687,7 +2868,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_by_id_replace) { - /* op_put_by_id_replace base(r) property(id) value(r) structure(sID) offset(n) nop(n) nop(n) + /* op_put_by_id_replace base(r) property(id) value(r) structure(sID) offset(n) nop(n) nop(n) direct(b) Cached property access: Attempts to set a pre-existing, cached property named by identifier property, belonging to register base, @@ -2698,7 +2879,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the register file. */ int base = vPC[1].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); if (LIKELY(baseValue.isCell())) { JSCell* baseCell = asCell(baseValue); @@ -2711,9 +2892,9 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe unsigned offset = vPC[5].u.operand; ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifier(vPC[2].u.operand))) == offset); - baseObject->putDirectOffset(offset, callFrame[value].jsValue(callFrame)); + baseObject->putDirectOffset(offset, callFrame->r(value).jsValue()); - vPC += 8; + vPC += OPCODE_LENGTH(op_put_by_id_replace); NEXT_INSTRUCTION(); } } @@ -2722,7 +2903,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_by_id_generic) { - /* op_put_by_id_generic base(r) property(id) value(r) nop(n) nop(n) nop(n) nop(n) + /* op_put_by_id_generic base(r) property(id) value(r) nop(n) nop(n) nop(n) nop(n) direct(b) Generic property access: Sets the property named by identifier property, belonging to register base, to register value. @@ -2733,14 +2914,19 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int base = vPC[1].u.operand; int property = vPC[2].u.operand; int value = vPC[3].u.operand; + int direct = vPC[8].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); Identifier& ident = callFrame->codeBlock()->identifier(property); PutPropertySlot slot; - baseValue.put(callFrame, ident, callFrame[value].jsValue(callFrame), slot); + if (direct) { + baseValue.putDirect(callFrame, ident, callFrame->r(value).jsValue(), slot); + ASSERT(slot.base() == baseValue); + } else + baseValue.put(callFrame, ident, callFrame->r(value).jsValue(), slot); CHECK_FOR_EXCEPTION(); - vPC += 8; + vPC += OPCODE_LENGTH(op_put_by_id_generic); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_del_by_id) { @@ -2751,16 +2937,43 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe boolean indicating success (if true) or failure (if false) to register dst. */ - int dst = (++vPC)->u.operand; - int base = (++vPC)->u.operand; - int property = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int base = vPC[2].u.operand; + int property = vPC[3].u.operand; - JSObject* baseObj = callFrame[base].jsValue(callFrame).toObject(callFrame); + JSObject* baseObj = callFrame->r(base).jsValue().toObject(callFrame); Identifier& ident = callFrame->codeBlock()->identifier(property); - JSValuePtr result = jsBoolean(baseObj->deleteProperty(callFrame, ident)); + JSValue result = jsBoolean(baseObj->deleteProperty(callFrame, ident)); + CHECK_FOR_EXCEPTION(); + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_del_by_id); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_get_by_pname) { + int dst = vPC[1].u.operand; + int base = vPC[2].u.operand; + int property = vPC[3].u.operand; + int expected = vPC[4].u.operand; + int iter = vPC[5].u.operand; + int i = vPC[6].u.operand; + + JSValue baseValue = callFrame->r(base).jsValue(); + JSPropertyNameIterator* it = callFrame->r(iter).propertyNameIterator(); + JSValue subscript = callFrame->r(property).jsValue(); + JSValue expectedSubscript = callFrame->r(expected).jsValue(); + int index = callFrame->r(i).i() - 1; + JSValue result; + int offset = 0; + if (subscript == expectedSubscript && baseValue.isCell() && (baseValue.asCell()->structure() == it->cachedStructure()) && it->getOffset(index, offset)) { + callFrame->r(dst) = asObject(baseValue)->getDirectOffset(offset); + vPC += OPCODE_LENGTH(op_get_by_pname); + NEXT_INSTRUCTION(); + } + Identifier propertyName(callFrame, subscript.toString(callFrame)); + result = baseValue.get(callFrame, propertyName); CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; - ++vPC; + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_get_by_pname); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_get_by_val) { @@ -2771,26 +2984,26 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe in register dst. property is nominally converted to string but numbers are treated more efficiently. */ - int dst = (++vPC)->u.operand; - int base = (++vPC)->u.operand; - int property = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int base = vPC[2].u.operand; + int property = vPC[3].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); - JSValuePtr subscript = callFrame[property].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); + JSValue subscript = callFrame->r(property).jsValue(); - JSValuePtr result; + JSValue result; - if (LIKELY(subscript.isUInt32Fast())) { - uint32_t i = subscript.getUInt32Fast(); - if (isJSArray(baseValue)) { + if (LIKELY(subscript.isUInt32())) { + uint32_t i = subscript.asUInt32(); + if (isJSArray(globalData, baseValue)) { JSArray* jsArray = asArray(baseValue); if (jsArray->canGetIndex(i)) result = jsArray->getIndex(i); else result = jsArray->JSArray::get(callFrame, i); - } else if (isJSString(baseValue) && asString(baseValue)->canGetIndex(i)) - result = asString(baseValue)->getIndex(&callFrame->globalData(), i); - else if (isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) + } else if (isJSString(globalData, baseValue) && asString(baseValue)->canGetIndex(i)) + result = asString(baseValue)->getIndex(callFrame, i); + else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) result = asByteArray(baseValue)->getIndex(callFrame, i); else result = baseValue.get(callFrame, i); @@ -2800,8 +3013,8 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe } CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; - ++vPC; + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_get_by_val); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_by_val) { @@ -2815,43 +3028,43 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Unlike many opcodes, this one does not write any output to the register file. */ - int base = (++vPC)->u.operand; - int property = (++vPC)->u.operand; - int value = (++vPC)->u.operand; + int base = vPC[1].u.operand; + int property = vPC[2].u.operand; + int value = vPC[3].u.operand; - JSValuePtr baseValue = callFrame[base].jsValue(callFrame); - JSValuePtr subscript = callFrame[property].jsValue(callFrame); + JSValue baseValue = callFrame->r(base).jsValue(); + JSValue subscript = callFrame->r(property).jsValue(); - if (LIKELY(subscript.isUInt32Fast())) { - uint32_t i = subscript.getUInt32Fast(); - if (isJSArray(baseValue)) { + if (LIKELY(subscript.isUInt32())) { + uint32_t i = subscript.asUInt32(); + if (isJSArray(globalData, baseValue)) { JSArray* jsArray = asArray(baseValue); if (jsArray->canSetIndex(i)) - jsArray->setIndex(i, callFrame[value].jsValue(callFrame)); + jsArray->setIndex(i, callFrame->r(value).jsValue()); else - jsArray->JSArray::put(callFrame, i, callFrame[value].jsValue(callFrame)); - } else if (isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) { + jsArray->JSArray::put(callFrame, i, callFrame->r(value).jsValue()); + } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) { JSByteArray* jsByteArray = asByteArray(baseValue); double dValue = 0; - JSValuePtr jsValue = callFrame[value].jsValue(callFrame); - if (jsValue.isInt32Fast()) - jsByteArray->setIndex(i, jsValue.getInt32Fast()); + JSValue jsValue = callFrame->r(value).jsValue(); + if (jsValue.isInt32()) + jsByteArray->setIndex(i, jsValue.asInt32()); else if (jsValue.getNumber(dValue)) jsByteArray->setIndex(i, dValue); else baseValue.put(callFrame, i, jsValue); } else - baseValue.put(callFrame, i, callFrame[value].jsValue(callFrame)); + baseValue.put(callFrame, i, callFrame->r(value).jsValue()); } else { Identifier property(callFrame, subscript.toString(callFrame)); if (!globalData->exception) { // Don't put to an object if toString threw an exception. PutPropertySlot slot; - baseValue.put(callFrame, property, callFrame[value].jsValue(callFrame), slot); + baseValue.put(callFrame, property, callFrame->r(value).jsValue(), slot); } } CHECK_FOR_EXCEPTION(); - ++vPC; + vPC += OPCODE_LENGTH(op_put_by_val); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_del_by_val) { @@ -2862,14 +3075,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe boolean indicating success (if true) or failure (if false) to register dst. */ - int dst = (++vPC)->u.operand; - int base = (++vPC)->u.operand; - int property = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int base = vPC[2].u.operand; + int property = vPC[3].u.operand; - JSObject* baseObj = callFrame[base].jsValue(callFrame).toObject(callFrame); // may throw + JSObject* baseObj = callFrame->r(base).jsValue().toObject(callFrame); // may throw - JSValuePtr subscript = callFrame[property].jsValue(callFrame); - JSValuePtr result; + JSValue subscript = callFrame->r(property).jsValue(); + JSValue result; uint32_t i; if (subscript.getUInt32(i)) result = jsBoolean(baseObj->deleteProperty(callFrame, i)); @@ -2881,8 +3094,8 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe } CHECK_FOR_EXCEPTION(); - callFrame[dst] = result; - ++vPC; + callFrame->r(dst) = result; + vPC += OPCODE_LENGTH(op_del_by_val); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_by_index) { @@ -2897,13 +3110,13 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe This opcode is mainly used to initialize array literals. */ - int base = (++vPC)->u.operand; - unsigned property = (++vPC)->u.operand; - int value = (++vPC)->u.operand; + int base = vPC[1].u.operand; + unsigned property = vPC[2].u.operand; + int value = vPC[3].u.operand; - callFrame[base].jsValue(callFrame).put(callFrame, property, callFrame[value].jsValue(callFrame)); + callFrame->r(base).jsValue().put(callFrame, property, callFrame->r(value).jsValue()); - ++vPC; + vPC += OPCODE_LENGTH(op_put_by_index); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_loop) { @@ -2918,7 +3131,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe #if ENABLE(OPCODE_STATS) OpcodeStats::resetLastInstruction(); #endif - int target = (++vPC)->u.operand; + int target = vPC[1].u.operand; CHECK_FOR_TIMEOUT(); vPC += target; NEXT_INSTRUCTION(); @@ -2932,7 +3145,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe #if ENABLE(OPCODE_STATS) OpcodeStats::resetLastInstruction(); #endif - int target = (++vPC)->u.operand; + int target = vPC[1].u.operand; vPC += target; NEXT_INSTRUCTION(); @@ -2946,15 +3159,35 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Additionally this loop instruction may terminate JS execution is the JS timeout is reached. */ - int cond = (++vPC)->u.operand; - int target = (++vPC)->u.operand; - if (callFrame[cond].jsValue(callFrame).toBoolean(callFrame)) { + int cond = vPC[1].u.operand; + int target = vPC[2].u.operand; + if (callFrame->r(cond).jsValue().toBoolean(callFrame)) { + vPC += target; + CHECK_FOR_TIMEOUT(); + NEXT_INSTRUCTION(); + } + + vPC += OPCODE_LENGTH(op_loop_if_true); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_loop_if_false) { + /* loop_if_true cond(r) target(offset) + + Jumps to offset target from the current instruction, if and + only if register cond converts to boolean as false. + + Additionally this loop instruction may terminate JS execution is + the JS timeout is reached. + */ + int cond = vPC[1].u.operand; + int target = vPC[2].u.operand; + if (!callFrame->r(cond).jsValue().toBoolean(callFrame)) { vPC += target; CHECK_FOR_TIMEOUT(); NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_loop_if_true); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_jtrue) { @@ -2963,14 +3196,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Jumps to offset target from the current instruction, if and only if register cond converts to boolean as true. */ - int cond = (++vPC)->u.operand; - int target = (++vPC)->u.operand; - if (callFrame[cond].jsValue(callFrame).toBoolean(callFrame)) { + int cond = vPC[1].u.operand; + int target = vPC[2].u.operand; + if (callFrame->r(cond).jsValue().toBoolean(callFrame)) { vPC += target; NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_jtrue); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_jfalse) { @@ -2979,14 +3212,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Jumps to offset target from the current instruction, if and only if register cond converts to boolean as false. */ - int cond = (++vPC)->u.operand; - int target = (++vPC)->u.operand; - if (!callFrame[cond].jsValue(callFrame).toBoolean(callFrame)) { + int cond = vPC[1].u.operand; + int target = vPC[2].u.operand; + if (!callFrame->r(cond).jsValue().toBoolean(callFrame)) { vPC += target; NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_jfalse); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_jeq_null) { @@ -2995,16 +3228,16 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Jumps to offset target from the current instruction, if and only if register src is null. */ - int src = (++vPC)->u.operand; - int target = (++vPC)->u.operand; - JSValuePtr srcValue = callFrame[src].jsValue(callFrame); + int src = vPC[1].u.operand; + int target = vPC[2].u.operand; + JSValue srcValue = callFrame->r(src).jsValue(); if (srcValue.isUndefinedOrNull() || (srcValue.isCell() && srcValue.asCell()->structure()->typeInfo().masqueradesAsUndefined())) { vPC += target; NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_jeq_null); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_jneq_null) { @@ -3013,20 +3246,38 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Jumps to offset target from the current instruction, if and only if register src is not null. */ - int src = (++vPC)->u.operand; - int target = (++vPC)->u.operand; - JSValuePtr srcValue = callFrame[src].jsValue(callFrame); + int src = vPC[1].u.operand; + int target = vPC[2].u.operand; + JSValue srcValue = callFrame->r(src).jsValue(); - if (!srcValue.isUndefinedOrNull() || (srcValue.isCell() && !srcValue.asCell()->structure()->typeInfo().masqueradesAsUndefined())) { + if (!srcValue.isUndefinedOrNull() && (!srcValue.isCell() || !srcValue.asCell()->structure()->typeInfo().masqueradesAsUndefined())) { vPC += target; NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_jneq_null); NEXT_INSTRUCTION(); } - DEFINE_OPCODE(op_loop_if_less) { - /* loop_if_less src1(r) src2(r) target(offset) + DEFINE_OPCODE(op_jneq_ptr) { + /* jneq_ptr src(r) ptr(jsCell) target(offset) + + Jumps to offset target from the current instruction, if the value r is equal + to ptr, using pointer equality. + */ + int src = vPC[1].u.operand; + JSValue ptr = JSValue(vPC[2].u.jsCell); + int target = vPC[3].u.operand; + JSValue srcValue = callFrame->r(src).jsValue(); + if (srcValue != ptr) { + vPC += target; + NEXT_INSTRUCTION(); + } + + vPC += OPCODE_LENGTH(op_jneq_ptr); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_loop_if_less) { + /* loop_if_less src1(r) src2(r) target(offset) Checks whether register src1 is less than register src2, as with the ECMAScript '<' operator, and then jumps to offset @@ -3036,9 +3287,9 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Additionally this loop instruction may terminate JS execution is the JS timeout is reached. */ - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int target = (++vPC)->u.operand; + JSValue src1 = callFrame->r(vPC[1].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[2].u.operand).jsValue(); + int target = vPC[3].u.operand; bool result = jsLess(callFrame, src1, src2); CHECK_FOR_EXCEPTION(); @@ -3049,7 +3300,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_loop_if_less); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_loop_if_lesseq) { @@ -3063,9 +3314,9 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Additionally this loop instruction may terminate JS execution is the JS timeout is reached. */ - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int target = (++vPC)->u.operand; + JSValue src1 = callFrame->r(vPC[1].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[2].u.operand).jsValue(); + int target = vPC[3].u.operand; bool result = jsLessEq(callFrame, src1, src2); CHECK_FOR_EXCEPTION(); @@ -3076,7 +3327,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_loop_if_lesseq); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_jnless) { @@ -3087,19 +3338,88 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe target from the current instruction, if and only if the result of the comparison is false. */ - JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame); - int target = (++vPC)->u.operand; + JSValue src1 = callFrame->r(vPC[1].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[2].u.operand).jsValue(); + int target = vPC[3].u.operand; + + bool result = jsLess(callFrame, src1, src2); + CHECK_FOR_EXCEPTION(); + + if (!result) { + vPC += target; + NEXT_INSTRUCTION(); + } + + vPC += OPCODE_LENGTH(op_jnless); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_jless) { + /* jless src1(r) src2(r) target(offset) + + Checks whether register src1 is less than register src2, as + with the ECMAScript '<' operator, and then jumps to offset + target from the current instruction, if and only if the + result of the comparison is true. + */ + JSValue src1 = callFrame->r(vPC[1].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[2].u.operand).jsValue(); + int target = vPC[3].u.operand; bool result = jsLess(callFrame, src1, src2); CHECK_FOR_EXCEPTION(); + if (result) { + vPC += target; + NEXT_INSTRUCTION(); + } + + vPC += OPCODE_LENGTH(op_jless); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_jnlesseq) { + /* jnlesseq src1(r) src2(r) target(offset) + + Checks whether register src1 is less than or equal to + register src2, as with the ECMAScript '<=' operator, + and then jumps to offset target from the current instruction, + if and only if theresult of the comparison is false. + */ + JSValue src1 = callFrame->r(vPC[1].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[2].u.operand).jsValue(); + int target = vPC[3].u.operand; + + bool result = jsLessEq(callFrame, src1, src2); + CHECK_FOR_EXCEPTION(); + if (!result) { vPC += target; NEXT_INSTRUCTION(); } - ++vPC; + vPC += OPCODE_LENGTH(op_jnlesseq); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_jlesseq) { + /* jlesseq src1(r) src2(r) target(offset) + + Checks whether register src1 is less than or equal to + register src2, as with the ECMAScript '<=' operator, + and then jumps to offset target from the current instruction, + if and only if the result of the comparison is true. + */ + JSValue src1 = callFrame->r(vPC[1].u.operand).jsValue(); + JSValue src2 = callFrame->r(vPC[2].u.operand).jsValue(); + int target = vPC[3].u.operand; + + bool result = jsLessEq(callFrame, src1, src2); + CHECK_FOR_EXCEPTION(); + + if (result) { + vPC += target; + NEXT_INSTRUCTION(); + } + + vPC += OPCODE_LENGTH(op_jlesseq); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_switch_imm) { @@ -3111,15 +3431,16 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe table, and the value at jumpTable[scrutinee value] is non-zero, then that value is used as the jump offset, otherwise defaultOffset is used. */ - int tableIndex = (++vPC)->u.operand; - int defaultOffset = (++vPC)->u.operand; - JSValuePtr scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame); - if (scrutinee.isInt32Fast()) - vPC += callFrame->codeBlock()->immediateSwitchJumpTable(tableIndex).offsetForValue(scrutinee.getInt32Fast(), defaultOffset); + int tableIndex = vPC[1].u.operand; + int defaultOffset = vPC[2].u.operand; + JSValue scrutinee = callFrame->r(vPC[3].u.operand).jsValue(); + if (scrutinee.isInt32()) + vPC += callFrame->codeBlock()->immediateSwitchJumpTable(tableIndex).offsetForValue(scrutinee.asInt32(), defaultOffset); else { - int32_t value; - if (scrutinee.numberToInt32(value)) - vPC += callFrame->codeBlock()->immediateSwitchJumpTable(tableIndex).offsetForValue(value, defaultOffset); + double value; + int32_t intValue; + if (scrutinee.getNumber(value) && ((intValue = static_cast(value)) == value)) + vPC += callFrame->codeBlock()->immediateSwitchJumpTable(tableIndex).offsetForValue(intValue, defaultOffset); else vPC += defaultOffset; } @@ -3134,17 +3455,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe table, and the value at jumpTable[scrutinee value] is non-zero, then that value is used as the jump offset, otherwise defaultOffset is used. */ - int tableIndex = (++vPC)->u.operand; - int defaultOffset = (++vPC)->u.operand; - JSValuePtr scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame); + int tableIndex = vPC[1].u.operand; + int defaultOffset = vPC[2].u.operand; + JSValue scrutinee = callFrame->r(vPC[3].u.operand).jsValue(); if (!scrutinee.isString()) vPC += defaultOffset; else { - UString::Rep* value = asString(scrutinee)->value().rep(); - if (value->size() != 1) + UString::Rep* value = asString(scrutinee)->value(callFrame).rep(); + if (value->length() != 1) vPC += defaultOffset; else - vPC += callFrame->codeBlock()->characterSwitchJumpTable(tableIndex).offsetForValue(value->data()[0], defaultOffset); + vPC += callFrame->codeBlock()->characterSwitchJumpTable(tableIndex).offsetForValue(value->characters()[0], defaultOffset); } NEXT_INSTRUCTION(); } @@ -3157,13 +3478,13 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe jump table, then the value associated with the string is used as the jump offset, otherwise defaultOffset is used. */ - int tableIndex = (++vPC)->u.operand; - int defaultOffset = (++vPC)->u.operand; - JSValuePtr scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame); + int tableIndex = vPC[1].u.operand; + int defaultOffset = vPC[2].u.operand; + JSValue scrutinee = callFrame->r(vPC[3].u.operand).jsValue(); if (!scrutinee.isString()) vPC += defaultOffset; else - vPC += callFrame->codeBlock()->stringSwitchJumpTable(tableIndex).offsetForValue(asString(scrutinee)->value().rep(), defaultOffset); + vPC += callFrame->codeBlock()->stringSwitchJumpTable(tableIndex).offsetForValue(asString(scrutinee)->value(callFrame).rep(), defaultOffset); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_new_func) { @@ -3174,12 +3495,12 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe constructor, using the rules for function declarations, and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int func = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int func = vPC[2].u.operand; - callFrame[dst] = callFrame->codeBlock()->function(func)->makeFunction(callFrame, callFrame->scopeChain()); + callFrame->r(dst) = JSValue(callFrame->codeBlock()->functionDecl(func)->make(callFrame, callFrame->scopeChain())); - ++vPC; + vPC += OPCODE_LENGTH(op_new_func); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_new_func_exp) { @@ -3190,12 +3511,27 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe constructor, using the rules for function expressions, and puts the result in register dst. */ - int dst = (++vPC)->u.operand; - int func = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int funcIndex = vPC[2].u.operand; + + FunctionExecutable* function = callFrame->codeBlock()->functionExpr(funcIndex); + JSFunction* func = function->make(callFrame, callFrame->scopeChain()); + + /* + The Identifier in a FunctionExpression can be referenced from inside + the FunctionExpression's FunctionBody to allow the function to call + itself recursively. However, unlike in a FunctionDeclaration, the + Identifier in a FunctionExpression cannot be referenced from and + does not affect the scope enclosing the FunctionExpression. + */ + if (!function->name().isNull()) { + JSStaticScopeObject* functionScopeObject = new (callFrame) JSStaticScopeObject(callFrame, function->name(), func, ReadOnly | DontDelete); + func->scope().push(functionScopeObject); + } - callFrame[dst] = callFrame->codeBlock()->functionExpression(func)->makeFunction(callFrame, callFrame->scopeChain()); + callFrame->r(dst) = JSValue(func); - ++vPC; + vPC += OPCODE_LENGTH(op_new_func_exp); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_call_eval) { @@ -3215,20 +3551,20 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int argCount = vPC[3].u.operand; int registerOffset = vPC[4].u.operand; - JSValuePtr funcVal = callFrame[func].jsValue(callFrame); + JSValue funcVal = callFrame->r(func).jsValue(); Register* newCallFrame = callFrame->registers() + registerOffset; Register* argv = newCallFrame - RegisterFile::CallFrameHeaderSize - argCount; - JSValuePtr thisValue = argv[0].jsValue(callFrame); - JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject(); + JSValue thisValue = argv[0].jsValue(); + JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject; if (thisValue == globalObject && funcVal == globalObject->evalFunction()) { - JSValuePtr result = callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue); + JSValue result = callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue); if (exceptionValue) goto vm_throw; - callFrame[dst] = result; + callFrame->r(dst) = result; - vPC += 5; + vPC += OPCODE_LENGTH(op_call_eval); NEXT_INSTRUCTION(); } @@ -3252,15 +3588,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int argCount = vPC[3].u.operand; int registerOffset = vPC[4].u.operand; - JSValuePtr v = callFrame[func].jsValue(callFrame); + JSValue v = callFrame->r(func).jsValue(); CallData callData; CallType callType = v.getCallData(callData); if (callType == CallTypeJS) { ScopeChainNode* callDataScopeChain = callData.js.scopeChain; - FunctionBodyNode* functionBodyNode = callData.js.functionBody; - CodeBlock* newCodeBlock = &functionBodyNode->bytecode(callDataScopeChain); + CodeBlock* newCodeBlock = &callData.js.functionExecutable->bytecode(callFrame, callDataScopeChain); CallFrame* previousCallFrame = callFrame; @@ -3290,20 +3625,20 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe ArgList args(thisRegister + 1, argCount - 1); // FIXME: All host methods should be calling toThisObject, but this is not presently the case. - JSValuePtr thisValue = thisRegister->jsValue(callFrame); + JSValue thisValue = thisRegister->jsValue(); if (thisValue == jsNull()) thisValue = callFrame->globalThisValue(); - JSValuePtr returnValue; + JSValue returnValue; { - SamplingTool::HostCallRecord callRecord(m_sampler); + SamplingTool::HostCallRecord callRecord(m_sampler.get()); returnValue = callData.native.function(newCallFrame, asObject(v), thisValue, args); } CHECK_FOR_EXCEPTION(); - callFrame[dst] = JSValuePtr(returnValue); + callFrame->r(dst) = returnValue; - vPC += 5; + vPC += OPCODE_LENGTH(op_call); NEXT_INSTRUCTION(); } @@ -3312,6 +3647,162 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe exceptionValue = createNotAFunctionError(callFrame, v, vPC - callFrame->codeBlock()->instructions().begin(), callFrame->codeBlock()); goto vm_throw; } + DEFINE_OPCODE(op_load_varargs) { + int argCountDst = vPC[1].u.operand; + int argsOffset = vPC[2].u.operand; + + JSValue arguments = callFrame->r(argsOffset).jsValue(); + uint32_t argCount = 0; + if (!arguments) { + argCount = (uint32_t)(callFrame->argumentCount()) - 1; + argCount = min(argCount, Arguments::MaxArguments); + int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize; + Register* newEnd = callFrame->registers() + sizeDelta; + if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) { + exceptionValue = createStackOverflowError(callFrame); + goto vm_throw; + } + ASSERT(!callFrame->callee()->isHostFunction()); + uint32_t expectedParams = callFrame->callee()->jsExecutable()->parameterCount(); + uint32_t inplaceArgs = min(argCount, expectedParams); + uint32_t i = 0; + Register* argStore = callFrame->registers() + argsOffset; + + // First step is to copy the "expected" parameters from their normal location relative to the callframe + for (; i < inplaceArgs; i++) + argStore[i] = callFrame->registers()[i - RegisterFile::CallFrameHeaderSize - expectedParams]; + // Then we copy any additional arguments that may be further up the stack ('-1' to account for 'this') + for (; i < argCount; i++) + argStore[i] = callFrame->registers()[i - RegisterFile::CallFrameHeaderSize - expectedParams - argCount - 1]; + } else if (!arguments.isUndefinedOrNull()) { + if (!arguments.isObject()) { + exceptionValue = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPC - callFrame->codeBlock()->instructions().begin(), callFrame->codeBlock()); + goto vm_throw; + } + if (asObject(arguments)->classInfo() == &Arguments::info) { + Arguments* args = asArguments(arguments); + argCount = args->numProvidedArguments(callFrame); + argCount = min(argCount, Arguments::MaxArguments); + int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize; + Register* newEnd = callFrame->registers() + sizeDelta; + if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) { + exceptionValue = createStackOverflowError(callFrame); + goto vm_throw; + } + args->copyToRegisters(callFrame, callFrame->registers() + argsOffset, argCount); + } else if (isJSArray(&callFrame->globalData(), arguments)) { + JSArray* array = asArray(arguments); + argCount = array->length(); + argCount = min(argCount, Arguments::MaxArguments); + int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize; + Register* newEnd = callFrame->registers() + sizeDelta; + if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) { + exceptionValue = createStackOverflowError(callFrame); + goto vm_throw; + } + array->copyToRegisters(callFrame, callFrame->registers() + argsOffset, argCount); + } else if (asObject(arguments)->inherits(&JSArray::info)) { + JSObject* argObject = asObject(arguments); + argCount = argObject->get(callFrame, callFrame->propertyNames().length).toUInt32(callFrame); + argCount = min(argCount, Arguments::MaxArguments); + int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize; + Register* newEnd = callFrame->registers() + sizeDelta; + if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) { + exceptionValue = createStackOverflowError(callFrame); + goto vm_throw; + } + Register* argsBuffer = callFrame->registers() + argsOffset; + for (uint32_t i = 0; i < argCount; ++i) { + argsBuffer[i] = asObject(arguments)->get(callFrame, i); + CHECK_FOR_EXCEPTION(); + } + } else { + exceptionValue = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPC - callFrame->codeBlock()->instructions().begin(), callFrame->codeBlock()); + goto vm_throw; + } + } + CHECK_FOR_EXCEPTION(); + callFrame->r(argCountDst) = Register::withInt(argCount + 1); + vPC += OPCODE_LENGTH(op_load_varargs); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_call_varargs) { + /* call_varargs dst(r) func(r) argCountReg(r) baseRegisterOffset(n) + + Perform a function call with a dynamic set of arguments. + + registerOffset is the distance the callFrame pointer should move + before the VM initializes the new call frame's header, excluding + space for arguments. + + dst is where op_ret should store its result. + */ + + int dst = vPC[1].u.operand; + int func = vPC[2].u.operand; + int argCountReg = vPC[3].u.operand; + int registerOffset = vPC[4].u.operand; + + JSValue v = callFrame->r(func).jsValue(); + int argCount = callFrame->r(argCountReg).i(); + registerOffset += argCount; + CallData callData; + CallType callType = v.getCallData(callData); + + if (callType == CallTypeJS) { + ScopeChainNode* callDataScopeChain = callData.js.scopeChain; + CodeBlock* newCodeBlock = &callData.js.functionExecutable->bytecode(callFrame, callDataScopeChain); + + CallFrame* previousCallFrame = callFrame; + + callFrame = slideRegisterWindowForCall(newCodeBlock, registerFile, callFrame, registerOffset, argCount); + if (UNLIKELY(!callFrame)) { + callFrame = previousCallFrame; + exceptionValue = createStackOverflowError(callFrame); + goto vm_throw; + } + + callFrame->init(newCodeBlock, vPC + 5, callDataScopeChain, previousCallFrame, dst, argCount, asFunction(v)); + vPC = newCodeBlock->instructions().begin(); + +#if ENABLE(OPCODE_STATS) + OpcodeStats::resetLastInstruction(); +#endif + + NEXT_INSTRUCTION(); + } + + if (callType == CallTypeHost) { + ScopeChainNode* scopeChain = callFrame->scopeChain(); + CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset); + newCallFrame->init(0, vPC + 5, scopeChain, callFrame, dst, argCount, 0); + + Register* thisRegister = newCallFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount; + ArgList args(thisRegister + 1, argCount - 1); + + // FIXME: All host methods should be calling toThisObject, but this is not presently the case. + JSValue thisValue = thisRegister->jsValue(); + if (thisValue == jsNull()) + thisValue = callFrame->globalThisValue(); + + JSValue returnValue; + { + SamplingTool::HostCallRecord callRecord(m_sampler.get()); + returnValue = callData.native.function(newCallFrame, asObject(v), thisValue, args); + } + CHECK_FOR_EXCEPTION(); + + callFrame->r(dst) = returnValue; + + vPC += OPCODE_LENGTH(op_call_varargs); + NEXT_INSTRUCTION(); + } + + ASSERT(callType == CallTypeNone); + + exceptionValue = createNotAFunctionError(callFrame, v, vPC - callFrame->codeBlock()->instructions().begin(), callFrame->codeBlock()); + goto vm_throw; + } DEFINE_OPCODE(op_tear_off_activation) { /* tear_off_activation activation(r) @@ -3325,12 +3816,12 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe This opcode should only be used immediately before op_ret. */ - int src = (++vPC)->u.operand; + int src = vPC[1].u.operand; ASSERT(callFrame->codeBlock()->needsFullScopeChain()); - asActivation(callFrame[src].getJSValue())->copyRegisters(callFrame->optionalCalleeArguments()); + asActivation(callFrame->r(src).jsValue())->copyRegisters(callFrame->optionalCalleeArguments()); - ++vPC; + vPC += OPCODE_LENGTH(op_tear_off_activation); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_tear_off_arguments) { @@ -3348,9 +3839,10 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe ASSERT(callFrame->codeBlock()->usesArguments() && !callFrame->codeBlock()->needsFullScopeChain()); - callFrame->optionalCalleeArguments()->copyRegisters(); + if (callFrame->optionalCalleeArguments()) + callFrame->optionalCalleeArguments()->copyRegisters(); - ++vPC; + vPC += OPCODE_LENGTH(op_tear_off_arguments); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_ret) { @@ -3363,21 +3855,21 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe register base to those of the calling function. */ - int result = (++vPC)->u.operand; + int result = vPC[1].u.operand; if (callFrame->codeBlock()->needsFullScopeChain()) callFrame->scopeChain()->deref(); - JSValuePtr returnValue = callFrame[result].jsValue(callFrame); + JSValue returnValue = callFrame->r(result).jsValue(); - vPC = callFrame->returnPC(); + vPC = callFrame->returnVPC(); int dst = callFrame->returnValueRegister(); callFrame = callFrame->callerFrame(); if (callFrame->hasHostCallFrameFlag()) return returnValue; - callFrame[dst] = JSValuePtr(returnValue); + callFrame->r(dst) = returnValue; NEXT_INSTRUCTION(); } @@ -3396,12 +3888,9 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe CodeBlock* codeBlock = callFrame->codeBlock(); for (size_t count = codeBlock->m_numVars; i < count; ++i) - callFrame[i] = jsUndefined(); + callFrame->r(i) = jsUndefined(); - for (size_t count = codeBlock->numberOfConstantRegisters(), j = 0; j < count; ++i, ++j) - callFrame[i] = codeBlock->constantRegister(j); - - ++vPC; + vPC += OPCODE_LENGTH(op_enter); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_enter_with_activation) { @@ -3421,17 +3910,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe CodeBlock* codeBlock = callFrame->codeBlock(); for (size_t count = codeBlock->m_numVars; i < count; ++i) - callFrame[i] = jsUndefined(); - - for (size_t count = codeBlock->numberOfConstantRegisters(), j = 0; j < count; ++i, ++j) - callFrame[i] = codeBlock->constantRegister(j); + callFrame->r(i) = jsUndefined(); - int dst = (++vPC)->u.operand; - JSActivation* activation = new (globalData) JSActivation(callFrame, static_cast(codeBlock->ownerNode())); - callFrame[dst] = activation; + int dst = vPC[1].u.operand; + JSActivation* activation = new (globalData) JSActivation(callFrame, static_cast(codeBlock->ownerExecutable())); + callFrame->r(dst) = JSValue(activation); callFrame->setScopeChain(callFrame->scopeChain()->copy()->push(activation)); - ++vPC; + vPC += OPCODE_LENGTH(op_enter_with_activation); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_convert_this) { @@ -3446,30 +3932,42 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe block. */ - int thisRegister = (++vPC)->u.operand; - JSValuePtr thisVal = callFrame[thisRegister].getJSValue(); + int thisRegister = vPC[1].u.operand; + JSValue thisVal = callFrame->r(thisRegister).jsValue(); if (thisVal.needsThisConversion()) - callFrame[thisRegister] = JSValuePtr(thisVal.toThisObject(callFrame)); + callFrame->r(thisRegister) = JSValue(thisVal.toThisObject(callFrame)); - ++vPC; + vPC += OPCODE_LENGTH(op_convert_this); NEXT_INSTRUCTION(); } - DEFINE_OPCODE(op_create_arguments) { + DEFINE_OPCODE(op_init_arguments) { /* create_arguments - Creates the 'arguments' object and places it in both the - 'arguments' call frame slot and the local 'arguments' - register. + Initialises the arguments object reference to null to ensure + we can correctly detect that we need to create it later (or + avoid creating it altogether). This opcode should only be used at the beginning of a code block. - */ + */ + callFrame->r(RegisterFile::ArgumentsRegister) = JSValue(); + vPC += OPCODE_LENGTH(op_init_arguments); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_create_arguments) { + /* create_arguments - Arguments* arguments = new (globalData) Arguments(callFrame); - callFrame->setCalleeArguments(arguments); - callFrame[RegisterFile::ArgumentsRegister] = arguments; + Creates the 'arguments' object and places it in both the + 'arguments' call frame slot and the local 'arguments' + register, if it has not already been initialised. + */ - ++vPC; + if (!callFrame->r(RegisterFile::ArgumentsRegister).jsValue()) { + Arguments* arguments = new (globalData) Arguments(callFrame); + callFrame->setCalleeArguments(arguments); + callFrame->r(RegisterFile::ArgumentsRegister) = JSValue(arguments); + } + vPC += OPCODE_LENGTH(op_create_arguments); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_construct) { @@ -3494,25 +3992,24 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int proto = vPC[5].u.operand; int thisRegister = vPC[6].u.operand; - JSValuePtr v = callFrame[func].jsValue(callFrame); + JSValue v = callFrame->r(func).jsValue(); ConstructData constructData; ConstructType constructType = v.getConstructData(constructData); if (constructType == ConstructTypeJS) { ScopeChainNode* callDataScopeChain = constructData.js.scopeChain; - FunctionBodyNode* functionBodyNode = constructData.js.functionBody; - CodeBlock* newCodeBlock = &functionBodyNode->bytecode(callDataScopeChain); + CodeBlock* newCodeBlock = &constructData.js.functionExecutable->bytecode(callFrame, callDataScopeChain); Structure* structure; - JSValuePtr prototype = callFrame[proto].jsValue(callFrame); + JSValue prototype = callFrame->r(proto).jsValue(); if (prototype.isObject()) structure = asObject(prototype)->inheritorID(); else - structure = callDataScopeChain->globalObject()->emptyObjectStructure(); + structure = callDataScopeChain->globalObject->emptyObjectStructure(); JSObject* newObject = new (globalData) JSObject(structure); - callFrame[thisRegister] = JSValuePtr(newObject); // "this" value + callFrame->r(thisRegister) = JSValue(newObject); // "this" value CallFrame* previousCallFrame = callFrame; @@ -3525,7 +4022,6 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe callFrame->init(newCodeBlock, vPC + 7, callDataScopeChain, previousCallFrame, dst, argCount, asFunction(v)); vPC = newCodeBlock->instructions().begin(); - #if ENABLE(OPCODE_STATS) OpcodeStats::resetLastInstruction(); #endif @@ -3540,15 +4036,15 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset); newCallFrame->init(0, vPC + 7, scopeChain, callFrame, dst, argCount, 0); - JSValuePtr returnValue; + JSValue returnValue; { - SamplingTool::HostCallRecord callRecord(m_sampler); + SamplingTool::HostCallRecord callRecord(m_sampler.get()); returnValue = constructData.native.function(newCallFrame, asObject(v), args); } CHECK_FOR_EXCEPTION(); - callFrame[dst] = JSValuePtr(returnValue); + callFrame->r(dst) = JSValue(returnValue); - vPC += 7; + vPC += OPCODE_LENGTH(op_construct); NEXT_INSTRUCTION(); } @@ -3564,16 +4060,36 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe the object in register override to register dst. */ - int dst = vPC[1].u.operand;; - if (LIKELY(callFrame[dst].jsValue(callFrame).isObject())) { - vPC += 3; + int dst = vPC[1].u.operand; + if (LIKELY(callFrame->r(dst).jsValue().isObject())) { + vPC += OPCODE_LENGTH(op_construct_verify); NEXT_INSTRUCTION(); } int override = vPC[2].u.operand; - callFrame[dst] = callFrame[override]; + callFrame->r(dst) = callFrame->r(override); + + vPC += OPCODE_LENGTH(op_construct_verify); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_strcat) { + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + int count = vPC[3].u.operand; + + callFrame->r(dst) = concatenateStrings(callFrame, &callFrame->registers()[src], count); + CHECK_FOR_EXCEPTION(); + vPC += OPCODE_LENGTH(op_strcat); + + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_to_primitive) { + int dst = vPC[1].u.operand; + int src = vPC[2].u.operand; + + callFrame->r(dst) = callFrame->r(src).jsValue().toPrimitive(callFrame); + vPC += OPCODE_LENGTH(op_to_primitive); - vPC += 3; NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_push_scope) { @@ -3583,15 +4099,15 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe of the current scope chain. The contents of the register scope are replaced by the result of toObject conversion of the scope. */ - int scope = (++vPC)->u.operand; - JSValuePtr v = callFrame[scope].jsValue(callFrame); + int scope = vPC[1].u.operand; + JSValue v = callFrame->r(scope).jsValue(); JSObject* o = v.toObject(callFrame); CHECK_FOR_EXCEPTION(); - callFrame[scope] = JSValuePtr(o); + callFrame->r(scope) = JSValue(o); callFrame->setScopeChain(callFrame->scopeChain()->push(o)); - ++vPC; + vPC += OPCODE_LENGTH(op_push_scope); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_pop_scope) { @@ -3601,47 +4117,69 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe */ callFrame->setScopeChain(callFrame->scopeChain()->pop()); - ++vPC; + vPC += OPCODE_LENGTH(op_pop_scope); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_get_pnames) { - /* get_pnames dst(r) base(r) + /* get_pnames dst(r) base(r) i(n) size(n) breakTarget(offset) Creates a property name list for register base and puts it - in register dst. This is not a true JavaScript value, just - a synthetic value used to keep the iteration state in a - register. + in register dst, initializing i and size for iteration. If + base is undefined or null, jumps to breakTarget. */ - int dst = (++vPC)->u.operand; - int base = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int base = vPC[2].u.operand; + int i = vPC[3].u.operand; + int size = vPC[4].u.operand; + int breakTarget = vPC[5].u.operand; + + JSValue v = callFrame->r(base).jsValue(); + if (v.isUndefinedOrNull()) { + vPC += breakTarget; + NEXT_INSTRUCTION(); + } - callFrame[dst] = JSPropertyNameIterator::create(callFrame, callFrame[base].jsValue(callFrame)); - ++vPC; + JSObject* o = v.toObject(callFrame); + Structure* structure = o->structure(); + JSPropertyNameIterator* jsPropertyNameIterator = structure->enumerationCache(); + if (!jsPropertyNameIterator || jsPropertyNameIterator->cachedPrototypeChain() != structure->prototypeChain(callFrame)) + jsPropertyNameIterator = JSPropertyNameIterator::create(callFrame, o); + + callFrame->r(dst) = jsPropertyNameIterator; + callFrame->r(base) = JSValue(o); + callFrame->r(i) = Register::withInt(0); + callFrame->r(size) = Register::withInt(jsPropertyNameIterator->size()); + vPC += OPCODE_LENGTH(op_get_pnames); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_next_pname) { - /* next_pname dst(r) iter(r) target(offset) + /* next_pname dst(r) base(r) i(n) size(n) iter(r) target(offset) - Tries to copies the next name from property name list in - register iter. If there are names left, then copies one to - register dst, and jumps to offset target. If there are none - left, invalidates the iterator and continues to the next + Copies the next name from the property name list in + register iter to dst, then jumps to offset target. If there are no + names left, invalidates the iterator and continues to the next instruction. */ - int dst = (++vPC)->u.operand; - int iter = (++vPC)->u.operand; - int target = (++vPC)->u.operand; - - JSPropertyNameIterator* it = callFrame[iter].propertyNameIterator(); - if (JSValuePtr temp = it->next(callFrame)) { - CHECK_FOR_TIMEOUT(); - callFrame[dst] = JSValuePtr(temp); - vPC += target; - NEXT_INSTRUCTION(); + int dst = vPC[1].u.operand; + int base = vPC[2].u.operand; + int i = vPC[3].u.operand; + int size = vPC[4].u.operand; + int iter = vPC[5].u.operand; + int target = vPC[6].u.operand; + + JSPropertyNameIterator* it = callFrame->r(iter).propertyNameIterator(); + while (callFrame->r(i).i() != callFrame->r(size).i()) { + JSValue key = it->get(callFrame, asObject(callFrame->r(base).jsValue()), callFrame->r(i).i()); + callFrame->r(i) = Register::withInt(callFrame->r(i).i() + 1); + if (key) { + CHECK_FOR_TIMEOUT(); + callFrame->r(dst) = key; + vPC += target; + NEXT_INSTRUCTION(); + } } - it->invalidate(); - ++vPC; + vPC += OPCODE_LENGTH(op_next_pname); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_jmp_scopes) { @@ -3651,8 +4189,8 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe specified by immediate number count, then jumps to offset target. */ - int count = (++vPC)->u.operand; - int target = (++vPC)->u.operand; + int count = vPC[1].u.operand; + int target = vPC[2].u.operand; ScopeChainNode* tmp = callFrame->scopeChain(); while (count--) @@ -3662,7 +4200,7 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe vPC += target; NEXT_INSTRUCTION(); } -#if HAVE(COMPUTED_GOTO) +#if ENABLE(COMPUTED_GOTO_INTERPRETER) // Appease GCC goto *(&&skip_new_scope); #endif @@ -3675,26 +4213,26 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe */ callFrame->setScopeChain(createExceptionScope(callFrame, vPC)); - vPC += 4; + vPC += OPCODE_LENGTH(op_push_new_scope); NEXT_INSTRUCTION(); } -#if HAVE(COMPUTED_GOTO) +#if ENABLE(COMPUTED_GOTO_INTERPRETER) skip_new_scope: #endif DEFINE_OPCODE(op_catch) { /* catch ex(r) - Retrieves the VMs current exception and puts it in register + Retrieves the VM's current exception and puts it in register ex. This is only valid after an exception has been raised, and usually forms the beginning of an exception handler. */ ASSERT(exceptionValue); ASSERT(!globalData->exception); - int ex = (++vPC)->u.operand; - callFrame[ex] = exceptionValue; - exceptionValue = noValue(); + int ex = vPC[1].u.operand; + callFrame->r(ex) = exceptionValue; + exceptionValue = JSValue(); - ++vPC; + vPC += OPCODE_LENGTH(op_catch); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_throw) { @@ -3708,8 +4246,8 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe else the script returns control to the nearest native caller. */ - int ex = (++vPC)->u.operand; - exceptionValue = callFrame[ex].jsValue(callFrame); + int ex = vPC[1].u.operand; + exceptionValue = callFrame->r(ex).jsValue(); handler = throwException(callFrame, exceptionValue, vPC - callFrame->codeBlock()->instructions().begin(), true); if (!handler) { @@ -3720,18 +4258,6 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe vPC = callFrame->codeBlock()->instructions().begin() + handler->target; NEXT_INSTRUCTION(); } - DEFINE_OPCODE(op_unexpected_load) { - /* unexpected_load load dst(r) src(k) - - Copies constant src to register dst. - */ - int dst = (++vPC)->u.operand; - int src = (++vPC)->u.operand; - callFrame[dst] = JSValuePtr(callFrame->codeBlock()->unexpectedConstant(src)); - - ++vPC; - NEXT_INSTRUCTION(); - } DEFINE_OPCODE(op_new_error) { /* new_error dst(r) type(n) message(k) @@ -3740,14 +4266,14 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe constant message as the message string. The result is written to register dst. */ - int dst = (++vPC)->u.operand; - int type = (++vPC)->u.operand; - int message = (++vPC)->u.operand; + int dst = vPC[1].u.operand; + int type = vPC[2].u.operand; + int message = vPC[3].u.operand; CodeBlock* codeBlock = callFrame->codeBlock(); - callFrame[dst] = JSValuePtr(Error::create(callFrame, (ErrorType)type, codeBlock->unexpectedConstant(message).toString(callFrame), codeBlock->lineNumberForBytecodeOffset(callFrame, vPC - codeBlock->instructions().begin()), codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL())); + callFrame->r(dst) = JSValue(Error::create(callFrame, (ErrorType)type, callFrame->r(message).jsValue().toString(callFrame), codeBlock->lineNumberForBytecodeOffset(callFrame, vPC - codeBlock->instructions().begin()), codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->sourceURL())); - ++vPC; + vPC += OPCODE_LENGTH(op_new_error); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_end) { @@ -3762,8 +4288,8 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe ASSERT(scopeChain->refCount > 1); scopeChain->deref(); } - int result = (++vPC)->u.operand; - return callFrame[result].jsValue(callFrame); + int result = vPC[1].u.operand; + return callFrame->r(result).jsValue(); } DEFINE_OPCODE(op_put_getter) { /* put_getter base(r) property(id) function(r) @@ -3776,17 +4302,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Unlike many opcodes, this one does not write any output to the register file. */ - int base = (++vPC)->u.operand; - int property = (++vPC)->u.operand; - int function = (++vPC)->u.operand; + int base = vPC[1].u.operand; + int property = vPC[2].u.operand; + int function = vPC[3].u.operand; - ASSERT(callFrame[base].jsValue(callFrame).isObject()); - JSObject* baseObj = asObject(callFrame[base].jsValue(callFrame)); + ASSERT(callFrame->r(base).jsValue().isObject()); + JSObject* baseObj = asObject(callFrame->r(base).jsValue()); Identifier& ident = callFrame->codeBlock()->identifier(property); - ASSERT(callFrame[function].jsValue(callFrame).isObject()); - baseObj->defineGetter(callFrame, ident, asObject(callFrame[function].jsValue(callFrame))); + ASSERT(callFrame->r(function).jsValue().isObject()); + baseObj->defineGetter(callFrame, ident, asObject(callFrame->r(function).jsValue())); - ++vPC; + vPC += OPCODE_LENGTH(op_put_getter); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_put_setter) { @@ -3800,17 +4326,21 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Unlike many opcodes, this one does not write any output to the register file. */ - int base = (++vPC)->u.operand; - int property = (++vPC)->u.operand; - int function = (++vPC)->u.operand; + int base = vPC[1].u.operand; + int property = vPC[2].u.operand; + int function = vPC[3].u.operand; - ASSERT(callFrame[base].jsValue(callFrame).isObject()); - JSObject* baseObj = asObject(callFrame[base].jsValue(callFrame)); + ASSERT(callFrame->r(base).jsValue().isObject()); + JSObject* baseObj = asObject(callFrame->r(base).jsValue()); Identifier& ident = callFrame->codeBlock()->identifier(property); - ASSERT(callFrame[function].jsValue(callFrame).isObject()); - baseObj->defineSetter(callFrame, ident, asObject(callFrame[function].jsValue(callFrame))); + ASSERT(callFrame->r(function).jsValue().isObject()); + baseObj->defineSetter(callFrame, ident, asObject(callFrame->r(function).jsValue()), 0); - ++vPC; + vPC += OPCODE_LENGTH(op_put_setter); + NEXT_INSTRUCTION(); + } + DEFINE_OPCODE(op_method_check) { + vPC++; NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_jsr) { @@ -3819,9 +4349,9 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Places the address of the next instruction into the retAddrDst register and jumps to offset target from the current instruction. */ - int retAddrDst = (++vPC)->u.operand; - int target = (++vPC)->u.operand; - callFrame[retAddrDst] = vPC + 1; + int retAddrDst = vPC[1].u.operand; + int target = vPC[2].u.operand; + callFrame->r(retAddrDst) = vPC + OPCODE_LENGTH(op_jsr); vPC += target; NEXT_INSTRUCTION(); @@ -3833,8 +4363,8 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe differs from op_jmp because the target address is stored in a register, not as an immediate. */ - int retAddrSrc = (++vPC)->u.operand; - vPC = callFrame[retAddrSrc].vPC(); + int retAddrSrc = vPC[1].u.operand; + vPC = callFrame->r(retAddrSrc).vPC(); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_debug) { @@ -3843,13 +4373,13 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe Notifies the debugger of the current state of execution. This opcode is only generated while the debugger is attached. */ - int debugHookID = (++vPC)->u.operand; - int firstLine = (++vPC)->u.operand; - int lastLine = (++vPC)->u.operand; + int debugHookID = vPC[1].u.operand; + int firstLine = vPC[2].u.operand; + int lastLine = vPC[3].u.operand; debug(callFrame, static_cast(debugHookID), firstLine, lastLine); - ++vPC; + vPC += OPCODE_LENGTH(op_debug); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_profile_will_call) { @@ -3861,9 +4391,9 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int function = vPC[1].u.operand; if (*enabledProfilerReference) - (*enabledProfilerReference)->willExecute(callFrame, callFrame[function].jsValue(callFrame)); + (*enabledProfilerReference)->willExecute(callFrame, callFrame->r(function).jsValue()); - vPC += 2; + vPC += OPCODE_LENGTH(op_profile_will_call); NEXT_INSTRUCTION(); } DEFINE_OPCODE(op_profile_did_call) { @@ -3875,13 +4405,13 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe int function = vPC[1].u.operand; if (*enabledProfilerReference) - (*enabledProfilerReference)->didExecute(callFrame, callFrame[function].jsValue(callFrame)); + (*enabledProfilerReference)->didExecute(callFrame, callFrame->r(function).jsValue()); - vPC += 2; + vPC += OPCODE_LENGTH(op_profile_did_call); NEXT_INSTRUCTION(); } vm_throw: { - globalData->exception = noValue(); + globalData->exception = JSValue(); if (!tickCount) { // The exceptionValue is a lie! (GCC produces bad code for reasons I // cannot fathom if we don't assign to the exceptionValue before branching) @@ -3897,16 +4427,17 @@ JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registe NEXT_INSTRUCTION(); } } -#if !HAVE(COMPUTED_GOTO) +#if !ENABLE(COMPUTED_GOTO_INTERPRETER) } // iterator loop ends #endif #undef NEXT_INSTRUCTION #undef DEFINE_OPCODE #undef CHECK_FOR_EXCEPTION #undef CHECK_FOR_TIMEOUT +#endif // ENABLE(INTERPRETER) } -JSValuePtr Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* function) const +JSValue Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* function) const { CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function); if (!functionCallFrame) @@ -3915,9 +4446,14 @@ JSValuePtr Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* func CodeBlock* codeBlock = functionCallFrame->codeBlock(); if (codeBlock->usesArguments()) { ASSERT(codeBlock->codeType() == FunctionCode); - SymbolTable& symbolTable = codeBlock->symbolTable(); + SymbolTable& symbolTable = *codeBlock->symbolTable(); int argumentsIndex = symbolTable.get(functionCallFrame->propertyNames().arguments.ustring().rep()).getIndex(); - return functionCallFrame[argumentsIndex].jsValue(callFrame); + if (!functionCallFrame->r(argumentsIndex).jsValue()) { + Arguments* arguments = new (callFrame) Arguments(functionCallFrame); + functionCallFrame->setCalleeArguments(arguments); + functionCallFrame->r(RegisterFile::ArgumentsRegister) = JSValue(arguments); + } + return functionCallFrame->r(argumentsIndex).jsValue(); } Arguments* arguments = functionCallFrame->optionalCalleeArguments(); @@ -3930,7 +4466,7 @@ JSValuePtr Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* func return arguments; } -JSValuePtr Interpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const +JSValue Interpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const { CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function); if (!functionCallFrame) @@ -3940,16 +4476,16 @@ JSValuePtr Interpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* f if (callerFrame->hasHostCallFrameFlag()) return jsNull(); - JSValuePtr caller = callerFrame->callee(); + JSValue caller = callerFrame->callee(); if (!caller) return jsNull(); return caller; } -void Interpreter::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValuePtr& function) const +void Interpreter::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue& function) const { - function = noValue(); + function = JSValue(); lineNumber = -1; sourceURL = UString(); @@ -3960,11 +4496,20 @@ void Interpreter::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intp CodeBlock* callerCodeBlock = callerFrame->codeBlock(); if (!callerCodeBlock) return; - - unsigned bytecodeOffset = bytecodeOffsetForPC(callerFrame, callerCodeBlock, callFrame->returnPC()); + unsigned bytecodeOffset = 0; +#if ENABLE(INTERPRETER) + if (!callerFrame->globalData().canUseJIT()) + bytecodeOffset = bytecodeOffsetForPC(callerFrame, callerCodeBlock, callFrame->returnVPC()); +#if ENABLE(JIT) + else + bytecodeOffset = bytecodeOffsetForPC(callerFrame, callerCodeBlock, callFrame->returnPC()); +#endif +#else + bytecodeOffset = bytecodeOffsetForPC(callerFrame, callerCodeBlock, callFrame->returnPC()); +#endif lineNumber = callerCodeBlock->lineNumberForBytecodeOffset(callerFrame, bytecodeOffset - 1); - sourceID = callerCodeBlock->ownerNode()->sourceID(); - sourceURL = callerCodeBlock->ownerNode()->sourceURL(); + sourceID = callerCodeBlock->ownerExecutable()->sourceID(); + sourceURL = callerCodeBlock->ownerExecutable()->sourceURL(); function = callerFrame->callee(); } @@ -3977,2113 +4522,40 @@ CallFrame* Interpreter::findFunctionCallFrame(CallFrame* callFrame, InternalFunc return 0; } -#if ENABLE(JIT) - -#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS) - -NEVER_INLINE void Interpreter::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValuePtr baseValue, const PutPropertySlot& slot) +void Interpreter::enableSampler() { - // The interpreter checks for recursion here; I do not believe this can occur in CTI. - - if (!baseValue.isCell()) - return; - - // Uncacheable: give up. - if (!slot.isCacheable()) { - ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast(cti_op_put_by_id_generic)); - return; - } - - JSCell* baseCell = asCell(baseValue); - Structure* structure = baseCell->structure(); - - if (structure->isDictionary()) { - ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast(cti_op_put_by_id_generic)); - return; - } - - // If baseCell != base, then baseCell must be a proxy for another object. - if (baseCell != slot.base()) { - ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast(cti_op_put_by_id_generic)); - return; - } - - StructureStubInfo* stubInfo = &codeBlock->getStubInfo(returnAddress); - - // Cache hit: Specialize instruction and ref Structures. - - // Structure transition, cache transition info - if (slot.type() == PutPropertySlot::NewProperty) { - StructureChain* prototypeChain = structure->prototypeChain(callFrame); - stubInfo->initPutByIdTransition(structure->previousID(), structure, prototypeChain); - JIT::compilePutByIdTransition(callFrame->scopeChain()->globalData, codeBlock, stubInfo, structure->previousID(), structure, slot.cachedOffset(), prototypeChain, returnAddress); - return; +#if ENABLE(OPCODE_SAMPLING) + if (!m_sampler) { + m_sampler.set(new SamplingTool(this)); + m_sampler->setup(); } - - stubInfo->initPutByIdReplace(structure); - -#if USE(CTI_REPATCH_PIC) - UNUSED_PARAM(callFrame); - JIT::patchPutByIdReplace(stubInfo, structure, slot.cachedOffset(), returnAddress); -#else - JIT::compilePutByIdReplace(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress); #endif } - -NEVER_INLINE void Interpreter::tryCTICacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValuePtr baseValue, const Identifier& propertyName, const PropertySlot& slot) +void Interpreter::dumpSampleData(ExecState* exec) { - // FIXME: Write a test that proves we need to check for recursion here just - // like the interpreter does, then add a check for recursion. - - // FIXME: Cache property access for immediates. - if (!baseValue.isCell()) { - ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast(cti_op_get_by_id_generic)); - return; - } - - if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) { -#if USE(CTI_REPATCH_PIC) - JIT::compilePatchGetArrayLength(callFrame->scopeChain()->globalData, codeBlock, returnAddress); +#if ENABLE(OPCODE_SAMPLING) + if (m_sampler) + m_sampler->dump(exec); #else - ctiPatchCallByReturnAddress(returnAddress, m_ctiArrayLengthTrampoline); + UNUSED_PARAM(exec); #endif - return; - } - if (isJSString(baseValue) && propertyName == callFrame->propertyNames().length) { - // The tradeoff of compiling an patched inline string length access routine does not seem - // to pay off, so we currently only do this for arrays. - ctiPatchCallByReturnAddress(returnAddress, m_ctiStringLengthTrampoline); - return; - } - - // Uncacheable: give up. - if (!slot.isCacheable()) { - ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast(cti_op_get_by_id_generic)); - return; - } - - JSCell* baseCell = asCell(baseValue); - Structure* structure = baseCell->structure(); - - if (structure->isDictionary()) { - ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast(cti_op_get_by_id_generic)); - return; - } - - // In the interpreter the last structure is trapped here; in CTI we use the - // *_second method to achieve a similar (but not quite the same) effect. - - StructureStubInfo* stubInfo = &codeBlock->getStubInfo(returnAddress); - - // Cache hit: Specialize instruction and ref Structures. - - if (slot.slotBase() == baseValue) { - // set this up, so derefStructures can do it's job. - stubInfo->initGetByIdSelf(structure); - -#if USE(CTI_REPATCH_PIC) - JIT::patchGetByIdSelf(stubInfo, structure, slot.cachedOffset(), returnAddress); -#else - JIT::compileGetByIdSelf(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress); -#endif - return; - } - - if (slot.slotBase() == structure->prototypeForLookup(callFrame)) { - ASSERT(slot.slotBase().isObject()); - - JSObject* slotBaseObject = asObject(slot.slotBase()); - - // Since we're accessing a prototype in a loop, it's a good bet that it - // should not be treated as a dictionary. - if (slotBaseObject->structure()->isDictionary()) - slotBaseObject->setStructure(Structure::fromDictionaryTransition(slotBaseObject->structure())); - - stubInfo->initGetByIdProto(structure, slotBaseObject->structure()); - - JIT::compileGetByIdProto(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, structure, slotBaseObject->structure(), slot.cachedOffset(), returnAddress); - return; - } - - size_t count = countPrototypeChainEntriesAndCheckForProxies(callFrame, baseValue, slot); - if (!count) { - stubInfo->opcodeID = op_get_by_id_generic; - return; - } - - StructureChain* prototypeChain = structure->prototypeChain(callFrame); - stubInfo->initGetByIdChain(structure, prototypeChain); - JIT::compileGetByIdChain(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, structure, prototypeChain, count, slot.cachedOffset(), returnAddress); -} +} +void Interpreter::startSampling() +{ +#if ENABLE(SAMPLING_THREAD) + if (!m_sampleEntryDepth) + SamplingThread::start(); + m_sampleEntryDepth++; #endif - -#if USE(JIT_STUB_ARGUMENT_VA_LIST) -#define SETUP_VA_LISTL_ARGS va_list vl_args; va_start(vl_args, args) -#else // JIT_STUB_ARGUMENT_REGISTER or JIT_STUB_ARGUMENT_STACK -#define SETUP_VA_LISTL_ARGS -#endif - -#ifndef NDEBUG - -extern "C" { - -static void jscGeneratedNativeCode() -{ - // When executing a CTI function (which might do an allocation), we hack the return address - // to pretend to be executing this function, to keep stack logging tools from blowing out - // memory. -} - -} - -struct StackHack { - ALWAYS_INLINE StackHack(void** location) - { - returnAddressLocation = location; - savedReturnAddress = *returnAddressLocation; - ctiSetReturnAddress(returnAddressLocation, reinterpret_cast(jscGeneratedNativeCode)); - } - ALWAYS_INLINE ~StackHack() - { - ctiSetReturnAddress(returnAddressLocation, savedReturnAddress); - } - - void** returnAddressLocation; - void* savedReturnAddress; -}; - -#define BEGIN_STUB_FUNCTION() SETUP_VA_LISTL_ARGS; StackHack stackHack(&STUB_RETURN_ADDRESS_SLOT) -#define STUB_SET_RETURN_ADDRESS(address) stackHack.savedReturnAddress = address -#define STUB_RETURN_ADDRESS stackHack.savedReturnAddress - -#else - -#define BEGIN_STUB_FUNCTION() SETUP_VA_LISTL_ARGS -#define STUB_SET_RETURN_ADDRESS(address) ctiSetReturnAddress(&STUB_RETURN_ADDRESS_SLOT, address); -#define STUB_RETURN_ADDRESS STUB_RETURN_ADDRESS_SLOT - -#endif - -// The reason this is not inlined is to avoid having to do a PIC branch -// to get the address of the ctiVMThrowTrampoline function. It's also -// good to keep the code size down by leaving as much of the exception -// handling code out of line as possible. -static NEVER_INLINE void returnToThrowTrampoline(JSGlobalData* globalData, void* exceptionLocation, void*& returnAddressSlot) -{ - ASSERT(globalData->exception); - globalData->exceptionLocation = exceptionLocation; - ctiSetReturnAddress(&returnAddressSlot, reinterpret_cast(ctiVMThrowTrampoline)); -} - -static NEVER_INLINE void throwStackOverflowError(CallFrame* callFrame, JSGlobalData* globalData, void* exceptionLocation, void*& returnAddressSlot) -{ - globalData->exception = createStackOverflowError(callFrame); - returnToThrowTrampoline(globalData, exceptionLocation, returnAddressSlot); -} - -#define VM_THROW_EXCEPTION() \ - do { \ - VM_THROW_EXCEPTION_AT_END(); \ - return 0; \ - } while (0) -#define VM_THROW_EXCEPTION_2() \ - do { \ - VM_THROW_EXCEPTION_AT_END(); \ - RETURN_PAIR(0, 0); \ - } while (0) -#define VM_THROW_EXCEPTION_AT_END() \ - returnToThrowTrampoline(ARG_globalData, STUB_RETURN_ADDRESS, STUB_RETURN_ADDRESS) - -#define CHECK_FOR_EXCEPTION() \ - do { \ - if (UNLIKELY(ARG_globalData->exception != noValue())) \ - VM_THROW_EXCEPTION(); \ - } while (0) -#define CHECK_FOR_EXCEPTION_AT_END() \ - do { \ - if (UNLIKELY(ARG_globalData->exception != noValue())) \ - VM_THROW_EXCEPTION_AT_END(); \ - } while (0) -#define CHECK_FOR_EXCEPTION_VOID() \ - do { \ - if (UNLIKELY(ARG_globalData->exception != noValue())) { \ - VM_THROW_EXCEPTION_AT_END(); \ - return; \ - } \ - } while (0) - -JSObject* Interpreter::cti_op_convert_this(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr v1 = ARG_src1; - CallFrame* callFrame = ARG_callFrame; - - JSObject* result = v1.toThisObject(callFrame); - CHECK_FOR_EXCEPTION_AT_END(); - return result; -} - -void Interpreter::cti_op_end(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ScopeChainNode* scopeChain = ARG_callFrame->scopeChain(); - ASSERT(scopeChain->refCount > 1); - scopeChain->deref(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_add(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr v1 = ARG_src1; - JSValuePtr v2 = ARG_src2; - - double left; - double right = 0.0; - - bool rightIsNumber = v2.getNumber(right); - if (rightIsNumber && v1.getNumber(left)) - return JSValuePtr::encode(jsNumber(ARG_globalData, left + right)); - - CallFrame* callFrame = ARG_callFrame; - - bool leftIsString = v1.isString(); - if (leftIsString && v2.isString()) { - RefPtr value = concatenate(asString(v1)->value().rep(), asString(v2)->value().rep()); - if (UNLIKELY(!value)) { - throwOutOfMemoryError(callFrame); - VM_THROW_EXCEPTION(); - } - - return JSValuePtr::encode(jsString(ARG_globalData, value.release())); - } - - if (rightIsNumber & leftIsString) { - RefPtr value = v2.isInt32Fast() ? - concatenate(asString(v1)->value().rep(), v2.getInt32Fast()) : - concatenate(asString(v1)->value().rep(), right); - - if (UNLIKELY(!value)) { - throwOutOfMemoryError(callFrame); - VM_THROW_EXCEPTION(); - } - return JSValuePtr::encode(jsString(ARG_globalData, value.release())); - } - - // All other cases are pretty uncommon - JSValuePtr result = jsAddSlowCase(callFrame, v1, v2); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_pre_inc(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr v = ARG_src1; - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, v.toNumber(callFrame) + 1); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -int Interpreter::cti_timeout_check(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - Interpreter* interpreter = ARG_globalData->interpreter; - - if (interpreter->checkTimeout(ARG_callFrame->dynamicGlobalObject())) { - ARG_globalData->exception = createInterruptedExecutionException(ARG_globalData); - VM_THROW_EXCEPTION_AT_END(); - } - - return interpreter->m_ticksUntilNextTimeoutCheck; -} - -void Interpreter::cti_register_file_check(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - if (LIKELY(ARG_registerFile->grow(ARG_callFrame + ARG_callFrame->codeBlock()->m_numCalleeRegisters))) - return; - - // Rewind to the previous call frame because op_call already optimistically - // moved the call frame forward. - CallFrame* oldCallFrame = ARG_callFrame->callerFrame(); - ARG_setCallFrame(oldCallFrame); - throwStackOverflowError(oldCallFrame, ARG_globalData, oldCallFrame->returnPC(), STUB_RETURN_ADDRESS); -} - -int Interpreter::cti_op_loop_if_less(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - CallFrame* callFrame = ARG_callFrame; - - bool result = jsLess(callFrame, src1, src2); - CHECK_FOR_EXCEPTION_AT_END(); - return result; -} - -int Interpreter::cti_op_loop_if_lesseq(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - CallFrame* callFrame = ARG_callFrame; - - bool result = jsLessEq(callFrame, src1, src2); - CHECK_FOR_EXCEPTION_AT_END(); - return result; -} - -JSObject* Interpreter::cti_op_new_object(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return constructEmptyObject(ARG_callFrame); -} - -void Interpreter::cti_op_put_by_id_generic(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - PutPropertySlot slot; - ARG_src1.put(ARG_callFrame, *ARG_id2, ARG_src3, slot); - CHECK_FOR_EXCEPTION_AT_END(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_generic(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Identifier& ident = *ARG_id2; - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(callFrame, ident, slot); - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS) - -void Interpreter::cti_op_put_by_id(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Identifier& ident = *ARG_id2; - - PutPropertySlot slot; - ARG_src1.put(callFrame, ident, ARG_src3, slot); - - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_put_by_id_second)); - - CHECK_FOR_EXCEPTION_AT_END(); -} - -void Interpreter::cti_op_put_by_id_second(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - PutPropertySlot slot; - ARG_src1.put(ARG_callFrame, *ARG_id2, ARG_src3, slot); - ARG_globalData->interpreter->tryCTICachePutByID(ARG_callFrame, ARG_callFrame->codeBlock(), STUB_RETURN_ADDRESS, ARG_src1, slot); - CHECK_FOR_EXCEPTION_AT_END(); -} - -void Interpreter::cti_op_put_by_id_fail(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Identifier& ident = *ARG_id2; - - PutPropertySlot slot; - ARG_src1.put(callFrame, ident, ARG_src3, slot); - - CHECK_FOR_EXCEPTION_AT_END(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Identifier& ident = *ARG_id2; - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(callFrame, ident, slot); - - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_second)); - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_second(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Identifier& ident = *ARG_id2; - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(callFrame, ident, slot); - - ARG_globalData->interpreter->tryCTICacheGetByID(callFrame, callFrame->codeBlock(), STUB_RETURN_ADDRESS, baseValue, ident, slot); - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_self_fail(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Identifier& ident = *ARG_id2; - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(callFrame, ident, slot); - - CHECK_FOR_EXCEPTION(); - - if (baseValue.isCell() - && slot.isCacheable() - && !asCell(baseValue)->structure()->isDictionary() - && slot.slotBase() == baseValue) { - - CodeBlock* codeBlock = callFrame->codeBlock(); - StructureStubInfo* stubInfo = &codeBlock->getStubInfo(STUB_RETURN_ADDRESS); - - ASSERT(slot.slotBase().isObject()); - - PolymorphicAccessStructureList* polymorphicStructureList; - int listIndex = 1; - - if (stubInfo->opcodeID == op_get_by_id_self) { - ASSERT(!stubInfo->stubRoutine); - polymorphicStructureList = new PolymorphicAccessStructureList(0, stubInfo->u.getByIdSelf.baseObjectStructure); - stubInfo->initGetByIdSelfList(polymorphicStructureList, 2); - } else { - polymorphicStructureList = stubInfo->u.getByIdSelfList.structureList; - listIndex = stubInfo->u.getByIdSelfList.listSize; - stubInfo->u.getByIdSelfList.listSize++; - } - - JIT::compileGetByIdSelfList(callFrame->scopeChain()->globalData, codeBlock, stubInfo, polymorphicStructureList, listIndex, asCell(baseValue)->structure(), slot.cachedOffset()); - - if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1)) - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_generic)); - } else { - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_generic)); - } - return JSValuePtr::encode(result); -} - -static PolymorphicAccessStructureList* getPolymorphicAccessStructureListSlot(StructureStubInfo* stubInfo, int& listIndex) -{ - PolymorphicAccessStructureList* prototypeStructureList = 0; - listIndex = 1; - - switch (stubInfo->opcodeID) { - case op_get_by_id_proto: - prototypeStructureList = new PolymorphicAccessStructureList(stubInfo->stubRoutine, stubInfo->u.getByIdProto.baseObjectStructure, stubInfo->u.getByIdProto.prototypeStructure); - stubInfo->stubRoutine = 0; - stubInfo->initGetByIdProtoList(prototypeStructureList, 2); - break; - case op_get_by_id_chain: - prototypeStructureList = new PolymorphicAccessStructureList(stubInfo->stubRoutine, stubInfo->u.getByIdChain.baseObjectStructure, stubInfo->u.getByIdChain.chain); - stubInfo->stubRoutine = 0; - stubInfo->initGetByIdProtoList(prototypeStructureList, 2); - break; - case op_get_by_id_proto_list: - prototypeStructureList = stubInfo->u.getByIdProtoList.structureList; - listIndex = stubInfo->u.getByIdProtoList.listSize; - stubInfo->u.getByIdProtoList.listSize++; - break; - default: - ASSERT_NOT_REACHED(); - } - - ASSERT(listIndex < POLYMORPHIC_LIST_CACHE_SIZE); - return prototypeStructureList; -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_list(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(callFrame, *ARG_id2, slot); - - CHECK_FOR_EXCEPTION(); - - if (!baseValue.isCell() || !slot.isCacheable() || asCell(baseValue)->structure()->isDictionary()) { - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_proto_fail)); - return JSValuePtr::encode(result); - } - - Structure* structure = asCell(baseValue)->structure(); - CodeBlock* codeBlock = callFrame->codeBlock(); - StructureStubInfo* stubInfo = &codeBlock->getStubInfo(STUB_RETURN_ADDRESS); - - ASSERT(slot.slotBase().isObject()); - JSObject* slotBaseObject = asObject(slot.slotBase()); - - if (slot.slotBase() == baseValue) - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_proto_fail)); - else if (slot.slotBase() == asCell(baseValue)->structure()->prototypeForLookup(callFrame)) { - // Since we're accessing a prototype in a loop, it's a good bet that it - // should not be treated as a dictionary. - if (slotBaseObject->structure()->isDictionary()) - slotBaseObject->setStructure(Structure::fromDictionaryTransition(slotBaseObject->structure())); - - int listIndex; - PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(stubInfo, listIndex); - - JIT::compileGetByIdProtoList(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, slotBaseObject->structure(), slot.cachedOffset()); - - if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1)) - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_proto_list_full)); - } else if (size_t count = countPrototypeChainEntriesAndCheckForProxies(callFrame, baseValue, slot)) { - int listIndex; - PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(stubInfo, listIndex); - - JIT::compileGetByIdChainList(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, structure->prototypeChain(callFrame), count, slot.cachedOffset()); - - if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1)) - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_proto_list_full)); - } else - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_id_proto_fail)); - - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_list_full(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot); - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_fail(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot); - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_array_fail(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot); - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); } - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_string_fail(STUB_ARGS) +void Interpreter::stopSampling() { - BEGIN_STUB_FUNCTION(); - - JSValuePtr baseValue = ARG_src1; - PropertySlot slot(baseValue); - JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot); - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - +#if ENABLE(SAMPLING_THREAD) + m_sampleEntryDepth--; + if (!m_sampleEntryDepth) + SamplingThread::stop(); #endif - -JSValueEncodedAsPointer* Interpreter::cti_op_instanceof(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr value = ARG_src1; - JSValuePtr baseVal = ARG_src2; - JSValuePtr proto = ARG_src3; - - // at least one of these checks must have failed to get to the slow case - ASSERT(!value.isCell() || !baseVal.isCell() || !proto.isCell() - || !value.isObject() || !baseVal.isObject() || !proto.isObject() - || (asObject(baseVal)->structure()->typeInfo().flags() & (ImplementsHasInstance | OverridesHasInstance)) != ImplementsHasInstance); - - if (!baseVal.isObject()) { - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createInvalidParamError(callFrame, "instanceof", baseVal, vPCIndex, codeBlock); - VM_THROW_EXCEPTION(); - } - - if (!asObject(baseVal)->structure()->typeInfo().implementsHasInstance()) - return JSValuePtr::encode(jsBoolean(false)); - - if (!proto.isObject()) { - throwError(callFrame, TypeError, "instanceof called on an object with an invalid prototype property."); - VM_THROW_EXCEPTION(); - } - - if (!value.isObject()) - return JSValuePtr::encode(jsBoolean(false)); - - JSValuePtr result = jsBoolean(asObject(baseVal)->hasInstance(callFrame, value, proto)); - CHECK_FOR_EXCEPTION_AT_END(); - - return JSValuePtr::encode(result); } -JSValueEncodedAsPointer* Interpreter::cti_op_del_by_id(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - JSObject* baseObj = ARG_src1.toObject(callFrame); - - JSValuePtr result = jsBoolean(baseObj->deleteProperty(callFrame, *ARG_id2)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_mul(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - double left; - double right; - if (src1.getNumber(left) && src2.getNumber(right)) - return JSValuePtr::encode(jsNumber(ARG_globalData, left * right)); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, src1.toNumber(callFrame) * src2.toNumber(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSObject* Interpreter::cti_op_new_func(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return ARG_func1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain()); -} - -void* Interpreter::cti_op_call_JSFunction(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - -#ifndef NDEBUG - CallData callData; - ASSERT(ARG_src1.getCallData(callData) == CallTypeJS); -#endif - - ScopeChainNode* callDataScopeChain = asFunction(ARG_src1)->m_scopeChain.node(); - CodeBlock* newCodeBlock = &asFunction(ARG_src1)->body()->bytecode(callDataScopeChain); - - if (!newCodeBlock->jitCode()) - JIT::compile(ARG_globalData, newCodeBlock); - - return newCodeBlock; -} - -VoidPtrPair Interpreter::cti_op_call_arityCheck(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - CodeBlock* newCodeBlock = ARG_codeBlock4; - int argCount = ARG_int3; - - ASSERT(argCount != newCodeBlock->m_numParameters); - - CallFrame* oldCallFrame = callFrame->callerFrame(); - - if (argCount > newCodeBlock->m_numParameters) { - size_t numParameters = newCodeBlock->m_numParameters; - Register* r = callFrame->registers() + numParameters; - - Register* argv = r - RegisterFile::CallFrameHeaderSize - numParameters - argCount; - for (size_t i = 0; i < numParameters; ++i) - argv[i + argCount] = argv[i]; - - callFrame = CallFrame::create(r); - callFrame->setCallerFrame(oldCallFrame); - } else { - size_t omittedArgCount = newCodeBlock->m_numParameters - argCount; - Register* r = callFrame->registers() + omittedArgCount; - Register* newEnd = r + newCodeBlock->m_numCalleeRegisters; - if (!ARG_registerFile->grow(newEnd)) { - // Rewind to the previous call frame because op_call already optimistically - // moved the call frame forward. - ARG_setCallFrame(oldCallFrame); - throwStackOverflowError(oldCallFrame, ARG_globalData, ARG_returnAddress2, STUB_RETURN_ADDRESS); - RETURN_PAIR(0, 0); - } - - Register* argv = r - RegisterFile::CallFrameHeaderSize - omittedArgCount; - for (size_t i = 0; i < omittedArgCount; ++i) - argv[i] = jsUndefined(); - - callFrame = CallFrame::create(r); - callFrame->setCallerFrame(oldCallFrame); - } - - RETURN_PAIR(newCodeBlock, callFrame); -} - -void* Interpreter::cti_vm_dontLazyLinkCall(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSFunction* callee = asFunction(ARG_src1); - CodeBlock* codeBlock = &callee->body()->bytecode(callee->m_scopeChain.node()); - if (!codeBlock->jitCode()) - JIT::compile(ARG_globalData, codeBlock); - - ctiPatchCallByReturnAddress(ARG_returnAddress2, ARG_globalData->interpreter->m_ctiVirtualCallLink); - - return codeBlock->jitCode(); -} - -void* Interpreter::cti_vm_lazyLinkCall(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSFunction* callee = asFunction(ARG_src1); - CodeBlock* codeBlock = &callee->body()->bytecode(callee->m_scopeChain.node()); - if (!codeBlock->jitCode()) - JIT::compile(ARG_globalData, codeBlock); - - CallLinkInfo* callLinkInfo = &ARG_callFrame->callerFrame()->codeBlock()->getCallLinkInfo(ARG_returnAddress2); - JIT::linkCall(callee, codeBlock, codeBlock->jitCode(), callLinkInfo, ARG_int3); - - return codeBlock->jitCode(); -} - -JSObject* Interpreter::cti_op_push_activation(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSActivation* activation = new (ARG_globalData) JSActivation(ARG_callFrame, static_cast(ARG_callFrame->codeBlock()->ownerNode())); - ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->copy()->push(activation)); - return activation; -} - -JSValueEncodedAsPointer* Interpreter::cti_op_call_NotJSFunction(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr funcVal = ARG_src1; - - CallData callData; - CallType callType = funcVal.getCallData(callData); - - ASSERT(callType != CallTypeJS); - - if (callType == CallTypeHost) { - int registerOffset = ARG_int2; - int argCount = ARG_int3; - CallFrame* previousCallFrame = ARG_callFrame; - CallFrame* callFrame = CallFrame::create(previousCallFrame->registers() + registerOffset); - - callFrame->init(0, static_cast(STUB_RETURN_ADDRESS), previousCallFrame->scopeChain(), previousCallFrame, 0, argCount, 0); - ARG_setCallFrame(callFrame); - - Register* argv = ARG_callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount; - ArgList argList(argv + 1, argCount - 1); - - JSValuePtr returnValue; - { - SamplingTool::HostCallRecord callRecord(CTI_SAMPLER); - - // FIXME: All host methods should be calling toThisObject, but this is not presently the case. - JSValuePtr thisValue = argv[0].jsValue(callFrame); - if (thisValue == jsNull()) - thisValue = callFrame->globalThisValue(); - - returnValue = callData.native.function(callFrame, asObject(funcVal), thisValue, argList); - } - ARG_setCallFrame(previousCallFrame); - CHECK_FOR_EXCEPTION(); - - return JSValuePtr::encode(returnValue); - } - - ASSERT(callType == CallTypeNone); - - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createNotAFunctionError(ARG_callFrame, funcVal, vPCIndex, codeBlock); - VM_THROW_EXCEPTION(); -} - -void Interpreter::cti_op_create_arguments(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame); - ARG_callFrame->setCalleeArguments(arguments); - ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments; -} - -void Interpreter::cti_op_create_arguments_no_params(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame, Arguments::NoParameters); - ARG_callFrame->setCalleeArguments(arguments); - ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments; -} - -void Interpreter::cti_op_tear_off_activation(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain()); - asActivation(ARG_src1)->copyRegisters(ARG_callFrame->optionalCalleeArguments()); -} - -void Interpreter::cti_op_tear_off_arguments(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ASSERT(ARG_callFrame->codeBlock()->usesArguments() && !ARG_callFrame->codeBlock()->needsFullScopeChain()); - ARG_callFrame->optionalCalleeArguments()->copyRegisters(); -} - -void Interpreter::cti_op_profile_will_call(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ASSERT(*ARG_profilerReference); - (*ARG_profilerReference)->willExecute(ARG_callFrame, ARG_src1); -} - -void Interpreter::cti_op_profile_did_call(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ASSERT(*ARG_profilerReference); - (*ARG_profilerReference)->didExecute(ARG_callFrame, ARG_src1); -} - -void Interpreter::cti_op_ret_scopeChain(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain()); - ARG_callFrame->scopeChain()->deref(); -} - -JSObject* Interpreter::cti_op_new_array(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ArgList argList(&ARG_callFrame->registers()[ARG_int1], ARG_int2); - return constructArray(ARG_callFrame, argList); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_resolve(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - ScopeChainNode* scopeChain = callFrame->scopeChain(); - - ScopeChainIterator iter = scopeChain->begin(); - ScopeChainIterator end = scopeChain->end(); - ASSERT(iter != end); - - Identifier& ident = *ARG_id1; - do { - JSObject* o = *iter; - PropertySlot slot(o); - if (o->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); - } - } while (++iter != end); - - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock); - VM_THROW_EXCEPTION(); -} - -JSObject* Interpreter::cti_op_construct_JSConstruct(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - -#ifndef NDEBUG - ConstructData constructData; - ASSERT(asFunction(ARG_src1)->getConstructData(constructData) == ConstructTypeJS); -#endif - - Structure* structure; - if (ARG_src4.isObject()) - structure = asObject(ARG_src4)->inheritorID(); - else - structure = asFunction(ARG_src1)->m_scopeChain.node()->globalObject()->emptyObjectStructure(); - return new (ARG_globalData) JSObject(structure); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_construct_NotJSConstruct(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr constrVal = ARG_src1; - int argCount = ARG_int3; - int thisRegister = ARG_int5; - - ConstructData constructData; - ConstructType constructType = constrVal.getConstructData(constructData); - - if (constructType == ConstructTypeHost) { - ArgList argList(callFrame->registers() + thisRegister + 1, argCount - 1); - - JSValuePtr returnValue; - { - SamplingTool::HostCallRecord callRecord(CTI_SAMPLER); - returnValue = constructData.native.function(callFrame, asObject(constrVal), argList); - } - CHECK_FOR_EXCEPTION(); - - return JSValuePtr::encode(returnValue); - } - - ASSERT(constructType == ConstructTypeNone); - - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createNotAConstructorError(callFrame, constrVal, vPCIndex, codeBlock); - VM_THROW_EXCEPTION(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_val(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Interpreter* interpreter = ARG_globalData->interpreter; - - JSValuePtr baseValue = ARG_src1; - JSValuePtr subscript = ARG_src2; - - JSValuePtr result; - - if (LIKELY(subscript.isUInt32Fast())) { - uint32_t i = subscript.getUInt32Fast(); - if (interpreter->isJSArray(baseValue)) { - JSArray* jsArray = asArray(baseValue); - if (jsArray->canGetIndex(i)) - result = jsArray->getIndex(i); - else - result = jsArray->JSArray::get(callFrame, i); - } else if (interpreter->isJSString(baseValue) && asString(baseValue)->canGetIndex(i)) - result = asString(baseValue)->getIndex(ARG_globalData, i); - else if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) { - // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks. - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_val_byte_array)); - return JSValuePtr::encode(asByteArray(baseValue)->getIndex(callFrame, i)); - } else - result = baseValue.get(callFrame, i); - } else { - Identifier property(callFrame, subscript.toString(callFrame)); - result = baseValue.get(callFrame, property); - } - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_get_by_val_byte_array(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Interpreter* interpreter = ARG_globalData->interpreter; - - JSValuePtr baseValue = ARG_src1; - JSValuePtr subscript = ARG_src2; - - JSValuePtr result; - - if (LIKELY(subscript.isUInt32Fast())) { - uint32_t i = subscript.getUInt32Fast(); - if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) { - // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks. - return JSValuePtr::encode(asByteArray(baseValue)->getIndex(callFrame, i)); - } - - result = baseValue.get(callFrame, i); - if (!interpreter->isJSByteArray(baseValue)) - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_get_by_val)); - } else { - Identifier property(callFrame, subscript.toString(callFrame)); - result = baseValue.get(callFrame, property); - } - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -VoidPtrPair Interpreter::cti_op_resolve_func(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - ScopeChainNode* scopeChain = callFrame->scopeChain(); - - ScopeChainIterator iter = scopeChain->begin(); - ScopeChainIterator end = scopeChain->end(); - - // FIXME: add scopeDepthIsZero optimization - - ASSERT(iter != end); - - Identifier& ident = *ARG_id1; - JSObject* base; - do { - base = *iter; - PropertySlot slot(base); - if (base->getPropertySlot(callFrame, ident, slot)) { - // ECMA 11.2.3 says that if we hit an activation the this value should be null. - // However, section 10.2.3 says that in the case where the value provided - // by the caller is null, the global object should be used. It also says - // that the section does not apply to internal functions, but for simplicity - // of implementation we use the global object anyway here. This guarantees - // that in host objects you always get a valid object for this. - // We also handle wrapper substitution for the global object at the same time. - JSObject* thisObj = base->toThisObject(callFrame); - JSValuePtr result = slot.getValue(callFrame, ident); - CHECK_FOR_EXCEPTION_AT_END(); - - RETURN_PAIR(thisObj, JSValuePtr::encode(result)); - } - ++iter; - } while (iter != end); - - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock); - VM_THROW_EXCEPTION_2(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_sub(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - double left; - double right; - if (src1.getNumber(left) && src2.getNumber(right)) - return JSValuePtr::encode(jsNumber(ARG_globalData, left - right)); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, src1.toNumber(callFrame) - src2.toNumber(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -void Interpreter::cti_op_put_by_val(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Interpreter* interpreter = ARG_globalData->interpreter; - - JSValuePtr baseValue = ARG_src1; - JSValuePtr subscript = ARG_src2; - JSValuePtr value = ARG_src3; - - if (LIKELY(subscript.isUInt32Fast())) { - uint32_t i = subscript.getUInt32Fast(); - if (interpreter->isJSArray(baseValue)) { - JSArray* jsArray = asArray(baseValue); - if (jsArray->canSetIndex(i)) - jsArray->setIndex(i, value); - else - jsArray->JSArray::put(callFrame, i, value); - } else if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) { - JSByteArray* jsByteArray = asByteArray(baseValue); - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_put_by_val_byte_array)); - // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks. - if (value.isInt32Fast()) { - jsByteArray->setIndex(i, value.getInt32Fast()); - return; - } else { - double dValue = 0; - if (value.getNumber(dValue)) { - jsByteArray->setIndex(i, dValue); - return; - } - } - - baseValue.put(callFrame, i, value); - } else - baseValue.put(callFrame, i, value); - } else { - Identifier property(callFrame, subscript.toString(callFrame)); - if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception. - PutPropertySlot slot; - baseValue.put(callFrame, property, value, slot); - } - } - - CHECK_FOR_EXCEPTION_AT_END(); -} - -void Interpreter::cti_op_put_by_val_array(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr baseValue = ARG_src1; - int i = ARG_int2; - JSValuePtr value = ARG_src3; - - ASSERT(ARG_globalData->interpreter->isJSArray(baseValue)); - - if (LIKELY(i >= 0)) - asArray(baseValue)->JSArray::put(callFrame, i, value); - else { - // This should work since we're re-boxing an immediate unboxed in JIT code. - ASSERT(JSValuePtr::makeInt32Fast(i)); - Identifier property(callFrame, JSValuePtr::makeInt32Fast(i).toString(callFrame)); - // FIXME: can toString throw an exception here? - if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception. - PutPropertySlot slot; - baseValue.put(callFrame, property, value, slot); - } - } - - CHECK_FOR_EXCEPTION_AT_END(); -} - -void Interpreter::cti_op_put_by_val_byte_array(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - Interpreter* interpreter = ARG_globalData->interpreter; - - JSValuePtr baseValue = ARG_src1; - JSValuePtr subscript = ARG_src2; - JSValuePtr value = ARG_src3; - - if (LIKELY(subscript.isUInt32Fast())) { - uint32_t i = subscript.getUInt32Fast(); - if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) { - JSByteArray* jsByteArray = asByteArray(baseValue); - - // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks. - if (value.isInt32Fast()) { - jsByteArray->setIndex(i, value.getInt32Fast()); - return; - } else { - double dValue = 0; - if (value.getNumber(dValue)) { - jsByteArray->setIndex(i, dValue); - return; - } - } - } - - if (!interpreter->isJSByteArray(baseValue)) - ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast(cti_op_put_by_val)); - baseValue.put(callFrame, i, value); - } else { - Identifier property(callFrame, subscript.toString(callFrame)); - if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception. - PutPropertySlot slot; - baseValue.put(callFrame, property, value, slot); - } - } - - CHECK_FOR_EXCEPTION_AT_END(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_lesseq(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsBoolean(jsLessEq(callFrame, ARG_src1, ARG_src2)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -int Interpreter::cti_op_loop_if_true(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - - CallFrame* callFrame = ARG_callFrame; - - bool result = src1.toBoolean(callFrame); - CHECK_FOR_EXCEPTION_AT_END(); - return result; -} - -JSValueEncodedAsPointer* Interpreter::cti_op_negate(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src = ARG_src1; - - double v; - if (src.getNumber(v)) - return JSValuePtr::encode(jsNumber(ARG_globalData, -v)); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, -src.toNumber(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_resolve_base(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSValuePtr::encode(inlineResolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain())); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_resolve_skip(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - ScopeChainNode* scopeChain = callFrame->scopeChain(); - - int skip = ARG_int2; - - ScopeChainIterator iter = scopeChain->begin(); - ScopeChainIterator end = scopeChain->end(); - ASSERT(iter != end); - while (skip--) { - ++iter; - ASSERT(iter != end); - } - Identifier& ident = *ARG_id1; - do { - JSObject* o = *iter; - PropertySlot slot(o); - if (o->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); - } - } while (++iter != end); - - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock); - VM_THROW_EXCEPTION(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_resolve_global(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - JSGlobalObject* globalObject = asGlobalObject(ARG_src1); - Identifier& ident = *ARG_id2; - unsigned globalResolveInfoIndex = ARG_int3; - ASSERT(globalObject->isGlobalObject()); - - PropertySlot slot(globalObject); - if (globalObject->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); - if (slot.isCacheable() && !globalObject->structure()->isDictionary() && slot.slotBase() == globalObject) { - GlobalResolveInfo& globalResolveInfo = callFrame->codeBlock()->globalResolveInfo(globalResolveInfoIndex); - if (globalResolveInfo.structure) - globalResolveInfo.structure->deref(); - globalObject->structure()->ref(); - globalResolveInfo.structure = globalObject->structure(); - globalResolveInfo.offset = slot.cachedOffset(); - return JSValuePtr::encode(result); - } - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); - } - - unsigned vPCIndex = callFrame->codeBlock()->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, callFrame->codeBlock()); - VM_THROW_EXCEPTION(); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_div(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - double left; - double right; - if (src1.getNumber(left) && src2.getNumber(right)) - return JSValuePtr::encode(jsNumber(ARG_globalData, left / right)); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, src1.toNumber(callFrame) / src2.toNumber(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_pre_dec(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr v = ARG_src1; - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, v.toNumber(callFrame) - 1); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -int Interpreter::cti_op_jless(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - CallFrame* callFrame = ARG_callFrame; - - bool result = jsLess(callFrame, src1, src2); - CHECK_FOR_EXCEPTION_AT_END(); - return result; -} - -JSValueEncodedAsPointer* Interpreter::cti_op_not(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src = ARG_src1; - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr result = jsBoolean(!src.toBoolean(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -int Interpreter::cti_op_jtrue(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - - CallFrame* callFrame = ARG_callFrame; - - bool result = src1.toBoolean(callFrame); - CHECK_FOR_EXCEPTION_AT_END(); - return result; -} - -VoidPtrPair Interpreter::cti_op_post_inc(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr v = ARG_src1; - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr number = v.toJSNumber(callFrame); - CHECK_FOR_EXCEPTION_AT_END(); - - RETURN_PAIR(JSValuePtr::encode(number), JSValuePtr::encode(jsNumber(ARG_globalData, number.uncheckedGetNumber() + 1))); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_eq(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - CallFrame* callFrame = ARG_callFrame; - - ASSERT(!JSValuePtr::areBothInt32Fast(src1, src2)); - JSValuePtr result = jsBoolean(JSValuePtr::equalSlowCaseInline(callFrame, src1, src2)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_lshift(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr val = ARG_src1; - JSValuePtr shift = ARG_src2; - - int32_t left; - uint32_t right; - if (JSValuePtr::areBothInt32Fast(val, shift)) - return JSValuePtr::encode(jsNumber(ARG_globalData, val.getInt32Fast() << (shift.getInt32Fast() & 0x1f))); - if (val.numberToInt32(left) && shift.numberToUInt32(right)) - return JSValuePtr::encode(jsNumber(ARG_globalData, left << (right & 0x1f))); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_bitand(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - int32_t left; - int32_t right; - if (src1.numberToInt32(left) && src2.numberToInt32(right)) - return JSValuePtr::encode(jsNumber(ARG_globalData, left & right)); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, src1.toInt32(callFrame) & src2.toInt32(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_rshift(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr val = ARG_src1; - JSValuePtr shift = ARG_src2; - - int32_t left; - uint32_t right; - if (JSFastMath::canDoFastRshift(val, shift)) - return JSValuePtr::encode(JSFastMath::rightShiftImmediateNumbers(val, shift)); - if (val.numberToInt32(left) && shift.numberToUInt32(right)) - return JSValuePtr::encode(jsNumber(ARG_globalData, left >> (right & 0x1f))); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_bitnot(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src = ARG_src1; - - int value; - if (src.numberToInt32(value)) - return JSValuePtr::encode(jsNumber(ARG_globalData, ~value)); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsNumber(ARG_globalData, ~src.toInt32(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -VoidPtrPair Interpreter::cti_op_resolve_with_base(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - ScopeChainNode* scopeChain = callFrame->scopeChain(); - - ScopeChainIterator iter = scopeChain->begin(); - ScopeChainIterator end = scopeChain->end(); - - // FIXME: add scopeDepthIsZero optimization - - ASSERT(iter != end); - - Identifier& ident = *ARG_id1; - JSObject* base; - do { - base = *iter; - PropertySlot slot(base); - if (base->getPropertySlot(callFrame, ident, slot)) { - JSValuePtr result = slot.getValue(callFrame, ident); - CHECK_FOR_EXCEPTION_AT_END(); - - RETURN_PAIR(base, JSValuePtr::encode(result)); - } - ++iter; - } while (iter != end); - - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock); - VM_THROW_EXCEPTION_2(); -} - -JSObject* Interpreter::cti_op_new_func_exp(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain()); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_mod(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr dividendValue = ARG_src1; - JSValuePtr divisorValue = ARG_src2; - - CallFrame* callFrame = ARG_callFrame; - double d = dividendValue.toNumber(callFrame); - JSValuePtr result = jsNumber(ARG_globalData, fmod(d, divisorValue.toNumber(callFrame))); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_less(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsBoolean(jsLess(callFrame, ARG_src1, ARG_src2)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_neq(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - ASSERT(!JSValuePtr::areBothInt32Fast(src1, src2)); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr result = jsBoolean(!JSValuePtr::equalSlowCaseInline(callFrame, src1, src2)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -VoidPtrPair Interpreter::cti_op_post_dec(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr v = ARG_src1; - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr number = v.toJSNumber(callFrame); - CHECK_FOR_EXCEPTION_AT_END(); - - RETURN_PAIR(JSValuePtr::encode(number), JSValuePtr::encode(jsNumber(ARG_globalData, number.uncheckedGetNumber() - 1))); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_urshift(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr val = ARG_src1; - JSValuePtr shift = ARG_src2; - - CallFrame* callFrame = ARG_callFrame; - - if (JSFastMath::canDoFastUrshift(val, shift)) - return JSValuePtr::encode(JSFastMath::rightShiftImmediateNumbers(val, shift)); - else { - JSValuePtr result = jsNumber(ARG_globalData, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); - } -} - -JSValueEncodedAsPointer* Interpreter::cti_op_bitxor(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr result = jsNumber(ARG_globalData, src1.toInt32(callFrame) ^ src2.toInt32(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSObject* Interpreter::cti_op_new_regexp(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_bitor(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr result = jsNumber(ARG_globalData, src1.toInt32(callFrame) | src2.toInt32(callFrame)); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_call_eval(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - RegisterFile* registerFile = ARG_registerFile; - - Interpreter* interpreter = ARG_globalData->interpreter; - - JSValuePtr funcVal = ARG_src1; - int registerOffset = ARG_int2; - int argCount = ARG_int3; - - Register* newCallFrame = callFrame->registers() + registerOffset; - Register* argv = newCallFrame - RegisterFile::CallFrameHeaderSize - argCount; - JSValuePtr thisValue = argv[0].jsValue(callFrame); - JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject(); - - if (thisValue == globalObject && funcVal == globalObject->evalFunction()) { - JSValuePtr exceptionValue = noValue(); - JSValuePtr result = interpreter->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue); - if (UNLIKELY(exceptionValue != noValue())) { - ARG_globalData->exception = exceptionValue; - VM_THROW_EXCEPTION_AT_END(); - } - return JSValuePtr::encode(result); - } - - return JSValuePtr::encode(jsImpossibleValue()); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_throw(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - - JSValuePtr exceptionValue = ARG_src1; - ASSERT(exceptionValue); - - HandlerInfo* handler = ARG_globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, true); - - if (!handler) { - *ARG_exception = exceptionValue; - return JSValuePtr::encode(jsNull()); - } - - ARG_setCallFrame(callFrame); - void* catchRoutine = handler->nativeCode; - ASSERT(catchRoutine); - STUB_SET_RETURN_ADDRESS(catchRoutine); - return JSValuePtr::encode(exceptionValue); -} - -JSPropertyNameIterator* Interpreter::cti_op_get_pnames(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_next_pname(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSPropertyNameIterator* it = ARG_pni1; - JSValuePtr temp = it->next(ARG_callFrame); - if (!temp) - it->invalidate(); - return JSValuePtr::encode(temp); -} - -JSObject* Interpreter::cti_op_push_scope(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSObject* o = ARG_src1.toObject(ARG_callFrame); - CHECK_FOR_EXCEPTION(); - ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->push(o)); - return o; -} - -void Interpreter::cti_op_pop_scope(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->pop()); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_typeof(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSValuePtr::encode(jsTypeStringForValue(ARG_callFrame, ARG_src1)); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_is_undefined(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr v = ARG_src1; - return JSValuePtr::encode(jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined())); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_is_boolean(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSValuePtr::encode(jsBoolean(ARG_src1.isBoolean())); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_is_number(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSValuePtr::encode(jsBoolean(ARG_src1.isNumber())); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_is_string(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSValuePtr::encode(jsBoolean(ARG_globalData->interpreter->isJSString(ARG_src1))); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_is_object(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSValuePtr::encode(jsBoolean(jsIsObjectType(ARG_src1))); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_is_function(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - return JSValuePtr::encode(jsBoolean(jsIsFunctionType(ARG_src1))); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_stricteq(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - return JSValuePtr::encode(jsBoolean(JSValuePtr::strictEqual(src1, src2))); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_nstricteq(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src1 = ARG_src1; - JSValuePtr src2 = ARG_src2; - - return JSValuePtr::encode(jsBoolean(!JSValuePtr::strictEqual(src1, src2))); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_to_jsnumber(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr src = ARG_src1; - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr result = src.toJSNumber(callFrame); - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -JSValueEncodedAsPointer* Interpreter::cti_op_in(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - JSValuePtr baseVal = ARG_src2; - - if (!baseVal.isObject()) { - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS); - ARG_globalData->exception = createInvalidParamError(callFrame, "in", baseVal, vPCIndex, codeBlock); - VM_THROW_EXCEPTION(); - } - - JSValuePtr propName = ARG_src1; - JSObject* baseObj = asObject(baseVal); - - uint32_t i; - if (propName.getUInt32(i)) - return JSValuePtr::encode(jsBoolean(baseObj->hasProperty(callFrame, i))); - - Identifier property(callFrame, propName.toString(callFrame)); - CHECK_FOR_EXCEPTION(); - return JSValuePtr::encode(jsBoolean(baseObj->hasProperty(callFrame, property))); -} - -JSObject* Interpreter::cti_op_push_new_scope(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSObject* scope = new (ARG_globalData) JSStaticScopeObject(ARG_callFrame, *ARG_id1, ARG_src2, DontDelete); - - CallFrame* callFrame = ARG_callFrame; - callFrame->setScopeChain(callFrame->scopeChain()->push(scope)); - return scope; -} - -void Interpreter::cti_op_jmp_scopes(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - unsigned count = ARG_int1; - CallFrame* callFrame = ARG_callFrame; - - ScopeChainNode* tmp = callFrame->scopeChain(); - while (count--) - tmp = tmp->pop(); - callFrame->setScopeChain(tmp); -} - -void Interpreter::cti_op_put_by_index(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - unsigned property = ARG_int2; - - ARG_src1.put(callFrame, property, ARG_src3); -} - -void* Interpreter::cti_op_switch_imm(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr scrutinee = ARG_src1; - unsigned tableIndex = ARG_int2; - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - - if (scrutinee.isInt32Fast()) - return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(scrutinee.getInt32Fast()); - else { - int32_t value; - if (scrutinee.numberToInt32(value)) - return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(value); - else - return codeBlock->immediateSwitchJumpTable(tableIndex).ctiDefault; - } -} - -void* Interpreter::cti_op_switch_char(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr scrutinee = ARG_src1; - unsigned tableIndex = ARG_int2; - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - - void* result = codeBlock->characterSwitchJumpTable(tableIndex).ctiDefault; - - if (scrutinee.isString()) { - UString::Rep* value = asString(scrutinee)->value().rep(); - if (value->size() == 1) - result = codeBlock->characterSwitchJumpTable(tableIndex).ctiForValue(value->data()[0]); - } - - return result; -} - -void* Interpreter::cti_op_switch_string(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - JSValuePtr scrutinee = ARG_src1; - unsigned tableIndex = ARG_int2; - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - - void* result = codeBlock->stringSwitchJumpTable(tableIndex).ctiDefault; - - if (scrutinee.isString()) { - UString::Rep* value = asString(scrutinee)->value().rep(); - result = codeBlock->stringSwitchJumpTable(tableIndex).ctiForValue(value); - } - - return result; -} - -JSValueEncodedAsPointer* Interpreter::cti_op_del_by_val(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - JSValuePtr baseValue = ARG_src1; - JSObject* baseObj = baseValue.toObject(callFrame); // may throw - - JSValuePtr subscript = ARG_src2; - JSValuePtr result; - uint32_t i; - if (subscript.getUInt32(i)) - result = jsBoolean(baseObj->deleteProperty(callFrame, i)); - else { - CHECK_FOR_EXCEPTION(); - Identifier property(callFrame, subscript.toString(callFrame)); - CHECK_FOR_EXCEPTION(); - result = jsBoolean(baseObj->deleteProperty(callFrame, property)); - } - - CHECK_FOR_EXCEPTION_AT_END(); - return JSValuePtr::encode(result); -} - -void Interpreter::cti_op_put_getter(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - ASSERT(ARG_src1.isObject()); - JSObject* baseObj = asObject(ARG_src1); - ASSERT(ARG_src3.isObject()); - baseObj->defineGetter(callFrame, *ARG_id2, asObject(ARG_src3)); -} - -void Interpreter::cti_op_put_setter(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - ASSERT(ARG_src1.isObject()); - JSObject* baseObj = asObject(ARG_src1); - ASSERT(ARG_src3.isObject()); - baseObj->defineSetter(callFrame, *ARG_id2, asObject(ARG_src3)); -} - -JSObject* Interpreter::cti_op_new_error(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - unsigned type = ARG_int1; - JSValuePtr message = ARG_src2; - unsigned bytecodeOffset = ARG_int3; - - unsigned lineNumber = codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset); - return Error::create(callFrame, static_cast(type), message.toString(callFrame), lineNumber, codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL()); -} - -void Interpreter::cti_op_debug(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - - int debugHookID = ARG_int1; - int firstLine = ARG_int2; - int lastLine = ARG_int3; - - ARG_globalData->interpreter->debug(callFrame, static_cast(debugHookID), firstLine, lastLine); -} - -JSValueEncodedAsPointer* Interpreter::cti_vm_throw(STUB_ARGS) -{ - BEGIN_STUB_FUNCTION(); - - CallFrame* callFrame = ARG_callFrame; - CodeBlock* codeBlock = callFrame->codeBlock(); - JSGlobalData* globalData = ARG_globalData; - - unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, globalData->exceptionLocation); - - JSValuePtr exceptionValue = globalData->exception; - ASSERT(exceptionValue); - globalData->exception = noValue(); - - HandlerInfo* handler = globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, false); - - if (!handler) { - *ARG_exception = exceptionValue; - return JSValuePtr::encode(jsNull()); - } - - ARG_setCallFrame(callFrame); - void* catchRoutine = handler->nativeCode; - ASSERT(catchRoutine); - STUB_SET_RETURN_ADDRESS(catchRoutine); - return JSValuePtr::encode(exceptionValue); -} - -#undef STUB_RETURN_ADDRESS -#undef STUB_SET_RETURN_ADDRESS -#undef BEGIN_STUB_FUNCTION -#undef CHECK_FOR_EXCEPTION -#undef CHECK_FOR_EXCEPTION_AT_END -#undef CHECK_FOR_EXCEPTION_VOID -#undef VM_THROW_EXCEPTION -#undef VM_THROW_EXCEPTION_2 -#undef VM_THROW_EXCEPTION_AT_END - -#endif // ENABLE(JIT) - } // namespace JSC