Changeset 34906 in webkit


Ignore:
Timestamp:
Jun 30, 2008 10:45:21 PM (16 years ago)
Author:
ggaren@apple.com
Message:

2008-06-30 Geoffrey Garen <​ggaren@apple.com>

Reviewed by Oliver Hunt.


Removed the "registerBase" abstraction. Since the register file never
reallocates, we can keep direct pointers into it, instead of
<registerBase, offset> tuples.


SunSpider says 0.8% faster.

Location:
trunk/JavaScriptCore
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r34904 r34906  
     12008-06-30  Geoffrey Garen  <ggaren@apple.com>
     2
     3        Reviewed by Oliver Hunt.
     4       
     5        Removed the "registerBase" abstraction. Since the register file never
     6        reallocates, we can keep direct pointers into it, instead of
     7        <registerBase, offset> tuples.
     8       
     9        SunSpider says 0.8% faster.
     10       
    1112008-06-30  Oliver Hunt  <oliver@apple.com>
    212

  • trunk/JavaScriptCore/VM/Machine.cpp

    r34885 r34906  
    354354}
    355355
    356 ALWAYS_INLINE void initializeCallFrame(Register* callFrame, CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain, int registerOffset, int returnValueRegister, int argv, int argc, int calledAsConstructor, JSValue* function)
     356ALWAYS_INLINE void initializeCallFrame(Register* callFrame, CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain, Register* r, int returnValueRegister, int argv, int argc, int calledAsConstructor, JSValue* function)
    357357{
    358358    callFrame[RegisterFile::CallerCodeBlock].u.codeBlock = codeBlock;
    359359    callFrame[RegisterFile::ReturnVPC].u.vPC = vPC + 1;
    360360    callFrame[RegisterFile::CallerScopeChain].u.scopeChain = scopeChain;
    361     callFrame[RegisterFile::CallerRegisterOffset].u.i = registerOffset;
     361    callFrame[RegisterFile::CallerRegisters].u.r = r;
    362362    callFrame[RegisterFile::ReturnValueRegister].u.i = returnValueRegister;
    363363    callFrame[RegisterFile::ArgumentStartRegister].u.i = argv; // original argument vector (for the sake of the "arguments" object)
    … …  
    368368}
    369369
    370 ALWAYS_INLINE Register* slideRegisterWindowForCall(ExecState* exec, CodeBlock* newCodeBlock, RegisterFile* registerFile, Register** registerBase, int registerOffset, int argv, int argc, JSValue*& exceptionValue)
    371 {
    372     Register* r = 0;
    373     int oldOffset = registerOffset;
    374     registerOffset += argv + newCodeBlock->numLocals;
    375     size_t size = registerOffset + newCodeBlock->numTemporaries;
     370ALWAYS_INLINE Register* slideRegisterWindowForCall(ExecState* exec, CodeBlock* newCodeBlock, RegisterFile* registerFile, Register* registerBase, Register* r, int argv, int argc, JSValue*& exceptionValue)
     371{
     372    size_t registerOffset = argv + newCodeBlock->numLocals;
     373    size_t size = r - registerBase + registerOffset + newCodeBlock->numTemporaries;
    376374
    377375    if (argc == newCodeBlock->numParameters) { // correct number of arguments
    378376        if (!registerFile->grow(size)) {
    379377            exceptionValue = createStackOverflowError(exec);
    380             return *registerBase + oldOffset;
    381         }
    382         r = (*registerBase) + registerOffset;
     378            return r;
     379        }
     380        r += registerOffset;
    383381    } else if (argc < newCodeBlock->numParameters) { // too few arguments -- fill in the blanks
    384382        if (!registerFile->grow(size)) {
    385383            exceptionValue = createStackOverflowError(exec);
    386             return *registerBase + oldOffset;
    387         }
    388         r = (*registerBase) + registerOffset;
     384            return r;
     385        }
     386        r += registerOffset;
    389387
    390388        int omittedArgCount = newCodeBlock->numParameters - argc;
    … …  
    399397        if (!registerFile->grow(size)) {
    400398            exceptionValue = createStackOverflowError(exec);
    401             return *registerBase + oldOffset;
    402         }
    403         r = (*registerBase) + registerOffset;
     399            return r;
     400        }
     401        r += registerOffset;
    404402
    405403        Register* it = r - newCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize - shift;
    … …  
    416414}
    417415
    418 ALWAYS_INLINE ScopeChainNode* scopeChainForCall(ExecState* exec, FunctionBodyNode* functionBodyNode, CodeBlock* newCodeBlock, ScopeChainNode* callDataScopeChain, Register** registerBase, Register* r)
     416ALWAYS_INLINE ScopeChainNode* scopeChainForCall(ExecState* exec, FunctionBodyNode* functionBodyNode, CodeBlock* newCodeBlock, ScopeChainNode* callDataScopeChain, Register* r)
    419417{
    420418    if (newCodeBlock->needsFullScopeChain) {
    421         JSActivation* activation = new (exec) JSActivation(functionBodyNode, registerBase, r - (*registerBase));
     419        JSActivation* activation = new (exec) JSActivation(functionBodyNode, r);
    422420        r[RegisterFile::OptionalCalleeActivation - RegisterFile::CallFrameHeaderSize - newCodeBlock->numLocals].u.jsValue = activation;
    423421
    … …  
    462460    }
    463461
    464     JSValue* result = exec->globalData().machine->execute(evalNode.get(), exec, thisObj, r - (*registerFile->basePointer()) + argv + argc, scopeChain, &exceptionValue);
     462    JSValue* result = exec->globalData().machine->execute(evalNode.get(), exec, thisObj, r - registerFile->base() + argv + argc, scopeChain, &exceptionValue);
    465463
    466464    if (*profiler)
    … …  
    563561}
    564562
    565 NEVER_INLINE bool Machine::unwindCallFrame(ExecState* exec, JSValue* exceptionValue, Register** registerBase, const Instruction*& vPC, CodeBlock*& codeBlock, JSValue**& k, ScopeChainNode*& scopeChain, Register*& r)
     563NEVER_INLINE bool Machine::unwindCallFrame(ExecState* exec, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock, JSValue**& k, ScopeChainNode*& scopeChain, Register*& r)
    566564{
    567565    CodeBlock* oldCodeBlock = codeBlock;
    … …  
    569567
    570568    if (Debugger* debugger = exec->dynamicGlobalObject()->debugger()) {
    571         DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, exceptionValue, registerBase, r - *registerBase);
     569        DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, exceptionValue);
    572570        if (callFrame[RegisterFile::Callee].u.jsObject)
    573571            debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->lastLine());
    … …  
    598596    k = codeBlock->jsValues.data();
    599597    scopeChain = callFrame[RegisterFile::CallerScopeChain].u.scopeChain;
    600     int callerRegisterOffset = callFrame[RegisterFile::CallerRegisterOffset].u.i;
    601     r = (*registerBase) + callerRegisterOffset;
    602     exec->m_callFrameOffset = callerRegisterOffset - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
     598    r = callFrame[RegisterFile::CallerRegisters].u.r;
     599    exec->m_callFrame = r - oldCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    603600    vPC = callFrame[RegisterFile::ReturnVPC].u.vPC;
    604601
    … …  
    606603}
    607604
    608 NEVER_INLINE Instruction* Machine::throwException(ExecState* exec, JSValue* exceptionValue, Register** registerBase, const Instruction* vPC, CodeBlock*& codeBlock, JSValue**& k, ScopeChainNode*& scopeChain, Register*& r)
     605NEVER_INLINE Instruction* Machine::throwException(ExecState* exec, JSValue* exceptionValue, const Instruction* vPC, CodeBlock*& codeBlock, JSValue**& k, ScopeChainNode*& scopeChain, Register*& r)
    609606{
    610607    // Set up the exception object
    … …  
    618615
    619616        if (exception->isWatchdogException()) {
    620             while (unwindCallFrame(exec, exceptionValue, registerBase, vPC, codeBlock, k, scopeChain, r)) {
     617            while (unwindCallFrame(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r)) {
    621618                 // Don't need handler checks or anything, we just want to unroll all the JS callframes possible.
    622619            }
    … …  
    626623
    627624    if (Debugger* debugger = exec->dynamicGlobalObject()->debugger()) {
    628         DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, exceptionValue, registerBase, r - *registerBase);
     625        DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, exceptionValue);
    629626        debugger->exception(debuggerCallFrame, codeBlock->ownerNode->sourceId(), codeBlock->lineNumberForVPC(vPC));
    630627    }
    … …  
    636633
    637634    while (!codeBlock->getHandlerForVPC(vPC, handlerVPC, scopeDepth)) {
    638         if (!unwindCallFrame(exec, exceptionValue, registerBase, vPC, codeBlock, k, scopeChain, r))
     635        if (!unwindCallFrame(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r))
    639636            return 0;
    640637    }
    … …  
    672669    globalObject->copyGlobalsTo(m_registerFile);
    673670
    674     Register* callFrame = *m_registerFile.basePointer() + oldSize;
     671    Register* callFrame = m_registerFile.base() + oldSize;
    675672
    676673    // a 0 codeBlock indicates a built-in caller
    … …  
    683680        scopeChain = scopeChain->copy();
    684681
    685     ExecState newExec(exec, &m_registerFile, scopeChain, -1);
     682    ExecState newExec(exec, &m_registerFile, scopeChain, 0);
    686683
    687684    Profiler** profiler = Profiler::enabledProfilerReference();
    … …  
    722719    }
    723720
    724     Register** registerBase = m_registerFile.basePointer();
    725     int registerOffset = oldSize;
    726     int callFrameOffset = registerOffset;
    727     Register* callFrame = (*registerBase) + callFrameOffset;
     721    Register* callFrame = m_registerFile.base() + oldSize;
    728722
    729723    // put args in place, including "this"
    … …  
    736730
    737731    // a 0 codeBlock indicates a built-in caller
    738     initializeCallFrame(callFrame, 0, 0, 0, registerOffset, 0, argv, argc, 0, function);
     732    initializeCallFrame(callFrame, 0, 0, 0, callFrame, 0, argv, argc, 0, function);
    739733
    740734    CodeBlock* newCodeBlock = &functionBodyNode->code(scopeChain);
    741     Register* r = slideRegisterWindowForCall(exec, newCodeBlock, &m_registerFile, registerBase, registerOffset, argv, argc, *exception);
     735    Register* r = slideRegisterWindowForCall(exec, newCodeBlock, &m_registerFile, m_registerFile.base(), callFrame, argv, argc, *exception);
    742736    if (*exception) {
    743737        m_registerFile.shrink(oldSize);
    … …  
    745739    }
    746740
    747     scopeChain = scopeChainForCall(exec, functionBodyNode, newCodeBlock, scopeChain, registerBase, r);
    748 
    749     ExecState newExec(exec, &m_registerFile, scopeChain, callFrameOffset);
     741    scopeChain = scopeChainForCall(exec, functionBodyNode, newCodeBlock, scopeChain, r);
     742
     743    ExecState newExec(exec, &m_registerFile, scopeChain, callFrame);
    750744
    751745    Profiler** profiler = Profiler::enabledProfilerReference();
    … …  
    802796    }
    803797
    804     Register* callFrame = *m_registerFile.basePointer() + registerOffset;
     798    Register* callFrame = m_registerFile.base() + registerOffset;
    805799
    806800    // a 0 codeBlock indicates a built-in caller
    807     initializeCallFrame(callFrame, 0, 0, 0, registerOffset, 0, 0, 0, 0, 0);
     801    initializeCallFrame(callFrame, 0, 0, 0, 0, 0, 0, 0, 0, 0);
    808802
    809803    Register* r = callFrame + RegisterFile::CallFrameHeaderSize + codeBlock->numVars;
    … …  
    813807        scopeChain = scopeChain->copy();
    814808
    815     ExecState newExec(exec, &m_registerFile, scopeChain, -1);
     809    ExecState newExec(exec, &m_registerFile, scopeChain, 0);
    816810
    817811    Profiler** profiler = Profiler::enabledProfilerReference();
    … …  
    839833}
    840834
    841 NEVER_INLINE void Machine::debug(ExecState* exec, const Instruction* vPC, const CodeBlock* codeBlock, ScopeChainNode* scopeChain, Register** registerBase, Register* r)
     835NEVER_INLINE void Machine::debug(ExecState* exec, const Instruction* vPC, const CodeBlock* codeBlock, ScopeChainNode* scopeChain, Register* r)
    842836{
    843837    int debugHookID = (++vPC)->u.operand;
    … …  
    849843        return;
    850844
    851     DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, 0, registerBase, r - *registerBase);
     845    DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, 0);
    852846
    853847    switch((DebugHookID)debugHookID) {
    … …  
    968962    Instruction* handlerVPC = 0;
    969963
    970     Register* registerBase = *registerFile->basePointer();
     964    Register* registerBase = registerFile->base();
    971965    Instruction* vPC = codeBlock->instructions.begin();
    972966    JSValue** k = codeBlock->jsValues.data();
    … …  
    10471041        int firstArg = (++vPC)->u.operand;
    10481042        int argCount = (++vPC)->u.operand;
    1049         ArgList args(reinterpret_cast<JSValue***>(&registerBase), r - registerBase + firstArg, argCount);
     1043        ArgList args(reinterpret_cast<JSValue**>(r) + firstArg, argCount);
    10501044        r[dst].u.jsValue = constructArray(exec, args);
    10511045
    … …  
    22392233            if (*enabledProfilerReference)
    22402234                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
    2241             int registerOffset = r - registerBase;
    2242             Register* callFrame = r + firstArg - RegisterFile::CallFrameHeaderSize;
    2243             int callFrameOffset = registerOffset + firstArg - RegisterFile::CallFrameHeaderSize;
    2244 
    2245             r[firstArg].u.jsValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].u.jsValue;
    2246             initializeCallFrame(callFrame, codeBlock, vPC, scopeChain, registerOffset, dst, firstArg, argCount, 0, v);
    22472235
    22482236            ScopeChainNode* callDataScopeChain = callData.js.scopeChain;
    22492237            FunctionBodyNode* functionBodyNode = callData.js.functionBody;
    2250 
    22512238            CodeBlock* newCodeBlock = &functionBodyNode->code(callDataScopeChain);
    2252             r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, &registerBase, registerOffset, firstArg, argCount, exceptionValue);
     2239
     2240            r[firstArg].u.jsValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].u.jsValue;
     2241
     2242            Register* callFrame = r + firstArg - RegisterFile::CallFrameHeaderSize;
     2243            initializeCallFrame(callFrame, codeBlock, vPC, scopeChain, r, dst, firstArg, argCount, 0, v);
     2244            exec->m_callFrame = callFrame;
     2245
     2246            r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, registerBase, r, firstArg, argCount, exceptionValue);
    22532247            if (UNLIKELY(exceptionValue != 0))
    22542248                goto vm_throw;
    22552249
    22562250            codeBlock = newCodeBlock;
    2257             exec->m_callFrameOffset = callFrameOffset;
    2258             setScopeChain(exec, scopeChain, scopeChainForCall(exec, functionBodyNode, codeBlock, callDataScopeChain, &registerBase, r));
     2251            setScopeChain(exec, scopeChain, scopeChainForCall(exec, functionBodyNode, codeBlock, callDataScopeChain, r));
    22592252            k = codeBlock->jsValues.data();
    22602253            vPC = codeBlock->instructions.begin();
    … …  
    22702263            if (*enabledProfilerReference)
    22712264                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
    2272             int registerOffset = r - registerBase;
    22732265
    22742266            JSValue* thisValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].u.jsValue;
    2275 
    2276             ArgList args(reinterpret_cast<JSValue***>(&registerBase), registerOffset + firstArg + 1, argCount - 1);
     2267            ArgList args(reinterpret_cast<JSValue**>(r) + firstArg + 1, argCount - 1);
    22772268
    22782269            JSValue* returnValue = callData.native.function(exec, static_cast<JSObject*>(v), thisValue, args);
    … …  
    23052296        int result = (++vPC)->u.operand;
    23062297
    2307         CodeBlock* oldCodeBlock = codeBlock;
    2308 
    2309         Register* callFrame = r - oldCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    2310         JSValue* returnValue = r[result].u.jsValue;
    2311 
     2298        Register* callFrame = r - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    23122299        if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue)) {
    23132300            ASSERT(!codeBlock->needsFullScopeChain || scopeChain->object == activation);
    … …  
    23222309            scopeChain->deref();
    23232310
     2311        JSValue* returnValue = r[result].u.jsValue;
    23242312        if (callFrame[RegisterFile::CalledAsConstructor].u.i && !returnValue->isObject()) {
    23252313            JSValue* thisObject = callFrame[RegisterFile::CallFrameHeaderSize].u.jsValue;
    … …  
    23342322        vPC = callFrame[RegisterFile::ReturnVPC].u.vPC;
    23352323        setScopeChain(exec, scopeChain, callFrame[RegisterFile::CallerScopeChain].u.scopeChain);
    2336         int callerRegisterOffset = callFrame[RegisterFile::CallerRegisterOffset].u.i;
    2337         r = registerBase + callerRegisterOffset;
    2338         exec->m_callFrameOffset = callerRegisterOffset - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
     2324        r = callFrame[RegisterFile::CallerRegisters].u.r;
     2325        exec->m_callFrame = r - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    23392326        int dst = callFrame[RegisterFile::ReturnValueRegister].u.i;
    23402327        r[dst].u.jsValue = returnValue;
    … …  
    23692356            if (*enabledProfilerReference)
    23702357                (*enabledProfilerReference)->willExecute(exec, constructor);
    2371 
    2372             int registerOffset = r - registerBase;
    2373             Register* callFrame = r + firstArg - RegisterFile::CallFrameHeaderSize;
    2374             int callFrameOffset = registerOffset + firstArg - RegisterFile::CallFrameHeaderSize;
    23752358
    23762359            JSObject* prototype;
    … …  
    23812364                prototype = scopeChain->globalObject()->objectPrototype();
    23822365            JSObject* newObject = new (exec) JSObject(prototype);
    2383             r[firstArg].u.jsValue = newObject; // "this" value
    2384 
    2385             initializeCallFrame(callFrame, codeBlock, vPC, scopeChain, registerOffset, dst, firstArg, argCount, 1, constructor);
    23862366
    23872367            ScopeChainNode* callDataScopeChain = constructData.js.scopeChain;
    23882368            FunctionBodyNode* functionBodyNode = constructData.js.functionBody;
    2389 
    23902369            CodeBlock* newCodeBlock = &functionBodyNode->code(callDataScopeChain);
    2391             r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, &registerBase, registerOffset, firstArg, argCount, exceptionValue);
     2370
     2371            r[firstArg].u.jsValue = newObject; // "this" value
     2372
     2373            Register* callFrame = r + firstArg - RegisterFile::CallFrameHeaderSize;
     2374            initializeCallFrame(callFrame, codeBlock, vPC, scopeChain, r, dst, firstArg, argCount, 1, constructor);
     2375            exec->m_callFrame = callFrame;
     2376
     2377            r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, registerBase, r, firstArg, argCount, exceptionValue);
    23922378            if (exceptionValue)
    23932379                goto vm_throw;
    23942380
    23952381            codeBlock = newCodeBlock;
    2396             exec->m_callFrameOffset = callFrameOffset;
    2397             setScopeChain(exec, scopeChain, scopeChainForCall(exec, functionBodyNode, codeBlock, callDataScopeChain, &registerBase, r));
     2382            setScopeChain(exec, scopeChain, scopeChainForCall(exec, functionBodyNode, codeBlock, callDataScopeChain, r));
    23982383            k = codeBlock->jsValues.data();
    23992384            vPC = codeBlock->instructions.begin();
    … …  
    24062391                (*enabledProfilerReference)->willExecute(exec, constructor);
    24072392
    2408             int registerOffset = r - registerBase;
    2409             ArgList args(reinterpret_cast<JSValue***>(&registerBase), registerOffset + firstArg + 1, argCount - 1);
     2393            ArgList args(reinterpret_cast<JSValue**>(r) + firstArg + 1, argCount - 1);
    24102394            JSValue* returnValue = constructData.native.function(exec, constructor, args);
    24112395
    … …  
    25382522        int ex = (++vPC)->u.operand;
    25392523        exceptionValue = r[ex].u.jsValue;
    2540         handlerVPC = throwException(exec, exceptionValue, &registerBase, vPC, codeBlock, k, scopeChain, r);
     2524        handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r);
    25412525        if (!handlerVPC) {
    25422526            *exception = exceptionValue;
    … …  
    26662650        */
    26672651
    2668         debug(exec, vPC, codeBlock, scopeChain, &registerBase, r);
     2652        debug(exec, vPC, codeBlock, scopeChain, r);
    26692653
    26702654        vPC += 4;
    … …  
    26782662            exceptionValue = createInterruptedExecutionException(exec);
    26792663        }
    2680         handlerVPC = throwException(exec, exceptionValue, &registerBase, vPC, codeBlock, k, scopeChain, r);
     2664        handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r);
    26812665        if (!handlerVPC) {
    26822666            *exception = exceptionValue;
    … …  
    26942678JSValue* Machine::retrieveArguments(ExecState* exec, JSFunction* function) const
    26952679{
    2696     Register** registerBase;
    2697     int callFrameOffset;
    2698 
    2699     if (!getCallFrame(exec, function, registerBase, callFrameOffset))
     2680    Register* callFrame = this->callFrame(exec, function);
     2681    if (!callFrame)
    27002682        return jsNull();
    27012683
    2702     Register* callFrame = (*registerBase) + callFrameOffset;
    27032684    JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue);
    27042685    if (!activation) {
    27052686        CodeBlock* codeBlock = &function->body->generatedCode();
    2706         activation = new (exec) JSActivation(function->body, registerBase, callFrameOffset + RegisterFile::CallFrameHeaderSize + codeBlock->numLocals);
     2687        activation = new (exec) JSActivation(function->body, callFrame + RegisterFile::CallFrameHeaderSize + codeBlock->numLocals);
    27072688        callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue = activation;
    27082689    }
    … …  
    27132694JSValue* Machine::retrieveCaller(ExecState* exec, JSFunction* function) const
    27142695{
    2715     Register** registerBase;
    2716     int callFrameOffset;
    2717     if (!getCallFrame(exec, function, registerBase, callFrameOffset))
     2696    Register* callFrame = this->callFrame(exec, function);
     2697    if (!callFrame)
    27182698        return jsNull();
    27192699
    2720     Register* callFrame = (*registerBase) + callFrameOffset;
    27212700    CodeBlock* callerCodeBlock = callFrame[RegisterFile::CallerCodeBlock].u.codeBlock;
    27222701    if (!callerCodeBlock)
    27232702        return jsNull();
    27242703
    2725     int callerCallFrameOffset = callFrame[RegisterFile::CallerRegisterOffset].u.i - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    2726     Register* callerCallFrame = (*registerBase) + callerCallFrameOffset;
    2727 
     2704    Register* callerCallFrame = callFrame[RegisterFile::CallerRegisters].u.r - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    27282705    if (JSValue* caller = callerCallFrame[RegisterFile::Callee].u.jsValue)
    27292706        return caller;
    … …  
    27322709}
    27332710
    2734 bool Machine::getCallFrame(ExecState* exec, JSFunction* function, Register**& registerBase, int& callFrameOffset) const
    2735 {
    2736     callFrameOffset = exec->m_callFrameOffset;
     2711Register* Machine::callFrame(ExecState* exec, JSFunction* function) const
     2712{
     2713    Register* callFrame = exec->m_callFrame;
    27372714
    27382715    while (1) {
    2739         while (callFrameOffset == -1) {
     2716        while (!callFrame) {
    27402717            exec = exec->m_prev;
    27412718            if (!exec)
    2742                 return false;
    2743             callFrameOffset = exec->m_callFrameOffset;
    2744         }
    2745 
    2746         registerBase = exec->m_registerFile->basePointer();
    2747         Register* callFrame = (*registerBase) + callFrameOffset;
     2719                return 0;
     2720            callFrame = exec->m_callFrame;
     2721        }
     2722
    27482723        if (callFrame[RegisterFile::Callee].u.jsValue == function)
    2749             return true;
     2724            return callFrame;
    27502725
    27512726        CodeBlock* callerCodeBlock = callFrame[RegisterFile::CallerCodeBlock].u.codeBlock;
    27522727        if (!callerCodeBlock) {
    2753             callFrameOffset = -1;
     2728            callFrame = 0;
    27542729            continue;
    27552730        }
    27562731       
    2757         callFrameOffset = callFrame[RegisterFile::CallerRegisterOffset].u.i - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    2758     }
    2759 }
    2760 
    2761 void Machine::getFunctionAndArguments(Register** registerBase, Register* callFrame, JSFunction*& function, Register*& argv, int& argc)
     2732        callFrame = callFrame[RegisterFile::CallerRegisters].u.r - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
     2733    }
     2734}
     2735
     2736void Machine::getArgumentsData(Register* callFrame, JSFunction*& function, Register*& argv, int& argc)
    27622737{
    27632738    function = static_cast<JSFunction*>(callFrame[RegisterFile::Callee].u.jsValue);
    27642739    ASSERT(function->inherits(&JSFunction::info));
    27652740
    2766     argv = (*registerBase) + callFrame[RegisterFile::CallerRegisterOffset].u.i + callFrame[RegisterFile::ArgumentStartRegister].u.i + 1; // skip "this"
    2767     argc = callFrame[RegisterFile::ArgumentCount].u.i - 1; // skip "this"
     2741    argv = callFrame[RegisterFile::CallerRegisters].u.r + callFrame[RegisterFile::ArgumentStartRegister].u.i + 1; //  + 1 to skip "this"
     2742    argc = callFrame[RegisterFile::ArgumentCount].u.i - 1; // - 1 to skip "this"
    27682743}
    27692744

  • trunk/JavaScriptCore/VM/Machine.h

    r34886 r34906  
    9696        JSValue* retrieveCaller(ExecState*, JSFunction*) const;
    9797
    98         void getFunctionAndArguments(Register** registerBase, Register* callFrame, JSFunction*&, Register*& argv, int& argc);
     98        void getArgumentsData(Register* callFrame, JSFunction*&, Register*& argv, int& argc);
    9999        void setTimeoutTime(unsigned timeoutTime) { m_timeoutTime = timeoutTime; }
    100100       
    … …  
    127127
    128128        ALWAYS_INLINE void setScopeChain(ExecState* exec, ScopeChainNode*&, ScopeChainNode*);
    129         NEVER_INLINE void debug(ExecState*, const Instruction*, const CodeBlock*, ScopeChainNode*, Register**, Register*);
     129        NEVER_INLINE void debug(ExecState*, const Instruction*, const CodeBlock*, ScopeChainNode*, Register*);
    130130
    131         NEVER_INLINE bool unwindCallFrame(ExecState*, JSValue*, Register**, const Instruction*&, CodeBlock*&, JSValue**&, ScopeChainNode*&, Register*&);
    132         NEVER_INLINE Instruction* throwException(ExecState*, JSValue*, Register**, const Instruction*, CodeBlock*&, JSValue**&, ScopeChainNode*&, Register*&);
     131        NEVER_INLINE bool unwindCallFrame(ExecState*, JSValue*, const Instruction*&, CodeBlock*&, JSValue**&, ScopeChainNode*&, Register*&);
     132        NEVER_INLINE Instruction* throwException(ExecState*, JSValue*, const Instruction*, CodeBlock*&, JSValue**&, ScopeChainNode*&, Register*&);
    133133
    134         bool getCallFrame(ExecState*, JSFunction*, Register**& registerBase, int& callFrameOffset) const;
     134        Register* callFrame(ExecState*, JSFunction*) const;
    135135
    136136        JSValue* privateExecute(ExecutionFlag, ExecState* = 0, RegisterFile* = 0, Register* = 0, ScopeChainNode* = 0, CodeBlock* = 0, JSValue** exception = 0);

  • trunk/JavaScriptCore/VM/RegisterFile.h

    r34886 r34906  
    9494            ReturnVPC,
    9595            CallerScopeChain,
    96             CallerRegisterOffset,
     96            CallerRegisters,
    9797            ReturnValueRegister,
    9898            ArgumentStartRegister,
    … …  
    134134        ~RegisterFile();
    135135
    136         // Pointer to a value that holds the base of this register file.
    137         Register** basePointer() { return &m_base; }
     136        Register* base() const { return m_base; }
    138137       
    139138        void setGlobalObject(JSGlobalObject* globalObject) { m_globalObject = globalObject; }

  • trunk/JavaScriptCore/kjs/DebuggerCallFrame.cpp

    r34838 r34906  
    3737namespace KJS {
    3838
    39 Register* DebuggerCallFrame::r() const
    40 {
    41     return *m_registerBase + m_registerOffset;
    42 }
    43 
    4439Register* DebuggerCallFrame::callFrame() const
    4540{
    46     return r() - m_codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
     41    return m_registers - m_codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
    4742}
    4843
    … …  
    7166        return 0;
    7267
    73     return static_cast<JSObject*>(r()[m_codeBlock->thisRegister].u.jsValue);
     68    return static_cast<JSObject*>(m_registers[m_codeBlock->thisRegister].u.jsValue);
    7469}
    7570

  • trunk/JavaScriptCore/kjs/DebuggerCallFrame.h

    r34838 r34906  
    4848        } Type;
    4949
    50         DebuggerCallFrame(JSGlobalObject* dynamicGlobalObject, const CodeBlock* codeBlock, ScopeChainNode* scopeChain, JSValue* exception, Register** registerBase, int registerOffset)
     50        DebuggerCallFrame(JSGlobalObject* dynamicGlobalObject, const CodeBlock* codeBlock, ScopeChainNode* scopeChain, Register* r, JSValue* exception)
    5151            : m_dynamicGlobalObject(dynamicGlobalObject)
    5252            , m_codeBlock(codeBlock)
    5353            , m_scopeChain(scopeChain)
     54            , m_registers(r)
    5455            , m_exception(exception)
    55             , m_registerBase(registerBase)
    56             , m_registerOffset(registerOffset)
    5756        {
    5857        }
    … …  
    6766
    6867    private:
    69         Register* r() const;
    7068        Register* callFrame() const;
    7169
    … …  
    7371        const CodeBlock* m_codeBlock;
    7472        ScopeChainNode* m_scopeChain;
     73        Register* m_registers;
    7574        JSValue* m_exception;
    76         Register** m_registerBase;
    77         int m_registerOffset;
    7875    };
    7976

  • trunk/JavaScriptCore/kjs/ExecState.cpp

    r34684 r34906  
    4040    , m_registerFile(0)
    4141    , m_scopeChain(globalScopeChain)
    42     , m_callFrameOffset(-1)
     42    , m_callFrame(0)
    4343{
    4444}
    4545
    46 ExecState::ExecState(ExecState* exec, RegisterFile* registerFile, ScopeChainNode* scopeChain, int callFrameOffset)
     46ExecState::ExecState(ExecState* exec, RegisterFile* registerFile, ScopeChainNode* scopeChain, Register* callFrame)
    4747    : m_globalObject(exec->m_globalObject)
    4848    , m_globalThisValue(exec->m_globalThisValue)
    … …  
    5252    , m_registerFile(registerFile)
    5353    , m_scopeChain(scopeChain)
    54     , m_callFrameOffset(callFrameOffset)
     54    , m_callFrame(callFrame)
    5555{
    5656    ASSERT(!exec->m_exception);

  • trunk/JavaScriptCore/kjs/ExecState.h

    r34684 r34906  
    3939    class Machine;
    4040    class ProgramNode;
     41    class Register;
    4142    class RegisterFile;
    4243    class ScopeNode;
    … …  
    9495        ExecState() { }
    9596
    96         ExecState(ExecState*, RegisterFile*, ScopeChainNode*, int callFrameOffset);
     97        ExecState(ExecState*, RegisterFile*, ScopeChainNode*, Register* callFrame);
    9798
    9899        bool isGlobalObject(JSObject*) const;
    … …  
    109110        RegisterFile* m_registerFile;
    110111        ScopeChainNode* m_scopeChain;
    111         int m_callFrameOffset; // A negative offset indicates a non-function scope.
     112        Register* m_callFrame; // The most recent call frame.
    112113    };
    113114

  • trunk/JavaScriptCore/kjs/JSActivation.cpp

    r34838 r34906  
    3939const ClassInfo JSActivation::info = { "JSActivation", 0, 0, 0 };
    4040
    41 JSActivation::JSActivation(PassRefPtr<FunctionBodyNode> functionBody, Register** registerBase, int registerOffset)
    42     : Base(new JSActivationData(functionBody, registerBase, registerOffset))
     41JSActivation::JSActivation(PassRefPtr<FunctionBodyNode> functionBody, Register* registers)
     42    : Base(new JSActivationData(functionBody, registers))
    4343{
    4444}
    … …  
    5555        return;
    5656
    57     copyRegisterArray(registers() - numLocals, numLocals);
     57    copyRegisterArray(d()->registers - numLocals, numLocals);
    5858}
    5959
    … …  
    156156JSObject* JSActivation::createArgumentsObject(ExecState* exec)
    157157{
    158     Register* callFrame = registers() - d()->functionBody->generatedCode().numLocals - RegisterFile::CallFrameHeaderSize;
     158    Register* callFrame = d()->registers - d()->functionBody->generatedCode().numLocals - RegisterFile::CallFrameHeaderSize;
    159159
    160160    JSFunction* function;
    161161    Register* argv;
    162162    int argc;
    163     exec->machine()->getFunctionAndArguments(registerBase(), callFrame, function, argv, argc);
    164     ArgList args(reinterpret_cast<JSValue***>(registerBase()), argv - *registerBase(), argc);
     163    exec->machine()->getArgumentsData(callFrame, function, argv, argc);
     164
     165    ArgList args(reinterpret_cast<JSValue**>(argv), argc);
    165166    return new (exec) Arguments(exec, function, args, this);
    166167}

  • trunk/JavaScriptCore/kjs/JSActivation.h

    r34838 r34906  
    4141    typedef JSVariableObject Base;
    4242    public:
    43         JSActivation(PassRefPtr<FunctionBodyNode>, Register**, int registerOffset);
     43        JSActivation(PassRefPtr<FunctionBodyNode>, Register*);
    4444        virtual ~JSActivation();
    4545       
    … …  
    6464    private:
    6565        struct JSActivationData : public JSVariableObjectData {
    66             JSActivationData(PassRefPtr<FunctionBodyNode> functionBody_, Register** registerBase, int registerOffset)
    67                 : JSVariableObjectData(&functionBody_->symbolTable(), registerBase, registerOffset)
     66            JSActivationData(PassRefPtr<FunctionBodyNode> functionBody_, Register* registers)
     67                : JSVariableObjectData(&functionBody_->symbolTable(), registers)
    6868                , functionBody(functionBody_)
    6969                , argumentsObject(0)

  • trunk/JavaScriptCore/kjs/JSGlobalObject.cpp

    r34876 r34906  
    395395{
    396396    ASSERT(!d()->registerArray);
     397    ASSERT(!d()->registerArraySize);
    397398
    398399    int numGlobals = registerFile.numGlobals();
    399400    if (!numGlobals) {
    400         ASSERT(!d()->registerOffset);
    401         d()->registerBase = 0;
     401        d()->registers = 0;
    402402        return;
    403403    }
    … …  
    415415
    416416    if (d()->registerArray) {
    417         memcpy(*registerFile.basePointer() - d()->registerOffset, d()->registerArray, d()->registerOffset * sizeof(Register));
     417        memcpy(registerFile.base() - d()->registerArraySize, d()->registerArray.get(), d()->registerArraySize * sizeof(Register));
    418418        setRegisterArray(0, 0);
    419419    }
    420420
    421     d()->registerBase = registerFile.basePointer();
    422     d()->registerOffset = 0;
     421    d()->registers = registerFile.base();
    423422}
    424423

  • trunk/JavaScriptCore/kjs/JSGlobalObject.h

    r34886 r34906  
    7575        struct JSGlobalObjectData : public JSVariableObjectData {
    7676            JSGlobalObjectData(JSGlobalObject* globalObject, JSObject* thisValue)
    77                 : JSVariableObjectData(&symbolTable, 0, 0)
     77                : JSVariableObjectData(&symbolTable, 0)
    7878                , globalScopeChain(globalObject, thisValue)
    7979            {
    … …  
    259259    inline void JSGlobalObject::addStaticGlobals(GlobalPropertyInfo* globals, int count)
    260260    {
    261         int numGlobals = d()->registerOffset;
    262         Register* registerArray = static_cast<Register*>(fastMalloc((numGlobals + count) * sizeof(Register)));
     261        size_t registerArraySize = d()->registerArraySize;
     262        Register* registerArray = static_cast<Register*>(fastMalloc((registerArraySize + count) * sizeof(Register)));
    263263        if (d()->registerArray)
    264             memcpy(registerArray + count, d()->registerArray, numGlobals * sizeof(Register));
    265         setRegisterArray(registerArray, numGlobals + count);
    266 
    267         for (int i = 0, index = -numGlobals - 1; i < count; ++i, --index) {
     264            memcpy(registerArray + count, d()->registerArray.get(), registerArraySize * sizeof(Register));
     265        setRegisterArray(registerArray, registerArraySize + count);
     266
     267        for (int i = 0, index = -registerArraySize - 1; i < count; ++i, --index) {
    268268            GlobalPropertyInfo& global = globals[i];
    269269            ASSERT(global.attributes & DontDelete);

  • trunk/JavaScriptCore/kjs/JSVariableObject.cpp

    r34838 r34906  
    7171        return;
    7272   
    73     Register* end = d->registerArray + d->registerOffset;
    74     for (Register* it = d->registerArray; it != end; ++it) {
     73    Register* end = d->registerArray.get() + d->registerArraySize;
     74    for (Register* it = d->registerArray.get(); it != end; ++it) {
    7575        JSValue* v = (*it).u.jsValue;
    7676        if (!v->marked())
    … …  
    9696void JSVariableObject::setRegisterArray(Register* registerArray, size_t count)
    9797{
    98     delete d->registerArray;
    99     d->registerArray = registerArray;
    100     d->registerBase = &d->registerArray;
    101     d->registerOffset = count;
     98    d->registerArray.set(registerArray);
     99    d->registerArraySize = count;
     100    d->registers = registerArray + count;
    102101}
    103102

  • trunk/JavaScriptCore/kjs/JSVariableObject.h

    r34838 r34906  
    3030#define JSVariableObject_h
    3131
     32#include "JSObject.h"
    3233#include "Register.h"
    3334#include "SymbolTable.h"
    3435#include "UnusedParam.h"
    35 #include "JSObject.h"
     36#include <wtf/OwnPtr.h>
    3637#include <wtf/UnusedParam.h>
    3738
    … …  
    5556        virtual bool getPropertyAttributes(ExecState*, const Identifier& propertyName, unsigned& attributes) const;
    5657
    57         JSValue*& valueAt(int index) const { return registers()[index].u.jsValue; }
     58        JSValue*& valueAt(int index) const { return d->registers[index].u.jsValue; }
    5859
    5960    protected:
    … …  
    6263        // size of a JSCell).
    6364        struct JSVariableObjectData {
    64             JSVariableObjectData(SymbolTable* symbolTable_, Register** registerBase_, int registerOffset_)
     65            JSVariableObjectData(SymbolTable* symbolTable_, Register* registers_)
    6566                : symbolTable(symbolTable_)
    66                 , registerBase(registerBase_)
    67                 , registerOffset(registerOffset_)
    68                 , registerArray(0)
     67                , registers(registers_)
     68                , registerArraySize(0)
    6969            {
    7070                ASSERT(symbolTable_);
    7171            }
    7272           
    73             ~JSVariableObjectData()
    74             {
    75                 delete registerArray;
    76             }
    77 
    7873            SymbolTable* symbolTable; // Maps name -> offset from "r" in register file.
    79 
    80             Register** registerBase; // Location where a pointer to the base of the register file is stored.
    81             int registerOffset; // Offset of "r", the register past the end of local storage.
    82 
    83             Register* registerArray; // Independent copy of registers that were once stored in the register file.
     74            Register* registers; // Pointers to the register past the end of local storage. (Local storage indexes are negative.)
     75            OwnPtr<Register> registerArray; // Independent copy of registers, used when a variable object copies its registers out of the register file.
     76            size_t registerArraySize;
    8477        };
    8578
    … …  
    9588        }
    9689
    97         Register** registerBase() const { return d->registerBase; }
    98         Register* registers() const { return *registerBase() + d->registerOffset; }
    99        
    10090        void copyRegisterArray(Register* src, size_t count);
    10191        void setRegisterArray(Register* registerArray, size_t count);

  • trunk/JavaScriptCore/kjs/list.cpp

    r34659 r34906  
    3535    result.m_vector.appendRange(start, end());
    3636    result.m_size = result.m_vector.size();
    37     result.m_bufferSlot = result.m_vector.dataSlot();
     37    result.m_buffer = result.m_vector.data();
    3838}
    3939
    … …  
    8080   
    8181    m_vector.uncheckedAppend(v);
    82     m_bufferSlot = m_vector.dataSlot();
     82    m_buffer = m_vector.data();
    8383}
    8484

  • trunk/JavaScriptCore/kjs/list.h

    r34659 r34906  
    5151#endif
    5252        {
    53             m_bufferSlot = m_vector.dataSlot();
    54             m_offset = 0;
     53            m_buffer = m_vector.data();
    5554            m_size = 0;
    5655        }
    5756
    5857        // Constructor for a read-only list whose data has already been allocated elsewhere.
    59         ArgList(JSValue*** bufferSlot, size_t offset, size_t size)
    60             : m_bufferSlot(bufferSlot)
    61             , m_offset(offset)
     58        ArgList(JSValue** buffer, size_t size)
     59            : m_buffer(buffer)
    6260            , m_size(size)
    6361            , m_markSet(0)
    … …  
    8078        {
    8179            if (i < m_size)
    82                 return buffer()[i];
     80                return m_buffer[i];
    8381            return jsUndefined();
    8482        }
    … …  
    8987        {
    9088            m_vector.clear();
     89            m_buffer = 0;
    9190            m_size = 0;
    9291        }
    … …  
    109108        void getSlice(int startIndex, ArgList& result) const;
    110109
    111         iterator begin() { return buffer(); }
    112         iterator end() { return buffer() + m_size; }
     110        iterator begin() { return m_buffer; }
     111        iterator end() { return m_buffer + m_size; }
    113112
    114         const_iterator begin() const { return buffer(); }
    115         const_iterator end() const { return buffer() + m_size; }
     113        const_iterator begin() const { return m_buffer; }
     114        const_iterator end() const { return m_buffer + m_size; }
    116115
    117116        static void markLists(ListSet&);
    … …  
    120119        void slowAppend(JSValue*);
    121120       
    122         JSValue** buffer() const { return *m_bufferSlot + m_offset; }
    123 
    124         JSValue*** m_bufferSlot;
    125         size_t m_offset;
     121        JSValue** m_buffer;
    126122        size_t m_size;
    127123
Note: See TracChangeset for help on using the changeset viewer.