Ignore:
Timestamp:
May 6, 2009, 11:36:35 PM (16 years ago)
Author:
[email protected]
Message:

2009-05-06 Geoffrey Garen <​[email protected]>

Reviewed by Gavin "++" Barraclough.


Added some abstraction around the JIT stub calling convention by creating
a struct to represent the persistent stack frame JIT code shares with
JIT stubs.


SunSpider reports no change.

  • jit/JIT.h:
  • jit/JITStubs.cpp: (JSC::JITStubs::cti_op_convert_this): (JSC::JITStubs::cti_op_end): (JSC::JITStubs::cti_op_add): (JSC::JITStubs::cti_op_pre_inc): (JSC::JITStubs::cti_timeout_check): (JSC::JITStubs::cti_register_file_check): (JSC::JITStubs::cti_op_loop_if_less): (JSC::JITStubs::cti_op_loop_if_lesseq): (JSC::JITStubs::cti_op_new_object): (JSC::JITStubs::cti_op_put_by_id_generic): (JSC::JITStubs::cti_op_get_by_id_generic): (JSC::JITStubs::cti_op_put_by_id): (JSC::JITStubs::cti_op_put_by_id_second): (JSC::JITStubs::cti_op_put_by_id_fail): (JSC::JITStubs::cti_op_get_by_id): (JSC::JITStubs::cti_op_get_by_id_second): (JSC::JITStubs::cti_op_get_by_id_self_fail): (JSC::JITStubs::cti_op_get_by_id_proto_list): (JSC::JITStubs::cti_op_get_by_id_proto_list_full): (JSC::JITStubs::cti_op_get_by_id_proto_fail): (JSC::JITStubs::cti_op_get_by_id_array_fail): (JSC::JITStubs::cti_op_get_by_id_string_fail): (JSC::JITStubs::cti_op_instanceof): (JSC::JITStubs::cti_op_del_by_id): (JSC::JITStubs::cti_op_mul): (JSC::JITStubs::cti_op_new_func): (JSC::JITStubs::cti_op_call_JSFunction): (JSC::JITStubs::cti_op_call_arityCheck): (JSC::JITStubs::cti_vm_dontLazyLinkCall): (JSC::JITStubs::cti_vm_lazyLinkCall): (JSC::JITStubs::cti_op_push_activation): (JSC::JITStubs::cti_op_call_NotJSFunction): (JSC::JITStubs::cti_op_create_arguments): (JSC::JITStubs::cti_op_create_arguments_no_params): (JSC::JITStubs::cti_op_tear_off_activation): (JSC::JITStubs::cti_op_tear_off_arguments): (JSC::JITStubs::cti_op_profile_will_call): (JSC::JITStubs::cti_op_profile_did_call): (JSC::JITStubs::cti_op_ret_scopeChain): (JSC::JITStubs::cti_op_new_array): (JSC::JITStubs::cti_op_resolve): (JSC::JITStubs::cti_op_construct_JSConstruct): (JSC::JITStubs::cti_op_construct_NotJSConstruct): (JSC::JITStubs::cti_op_get_by_val): (JSC::JITStubs::cti_op_get_by_val_string): (JSC::JITStubs::cti_op_get_by_val_byte_array): (JSC::JITStubs::cti_op_resolve_func): (JSC::JITStubs::cti_op_sub): (JSC::JITStubs::cti_op_put_by_val): (JSC::JITStubs::cti_op_put_by_val_array): (JSC::JITStubs::cti_op_put_by_val_byte_array): (JSC::JITStubs::cti_op_lesseq): (JSC::JITStubs::cti_op_loop_if_true): (JSC::JITStubs::cti_op_load_varargs): (JSC::JITStubs::cti_op_negate): (JSC::JITStubs::cti_op_resolve_base): (JSC::JITStubs::cti_op_resolve_skip): (JSC::JITStubs::cti_op_resolve_global): (JSC::JITStubs::cti_op_div): (JSC::JITStubs::cti_op_pre_dec): (JSC::JITStubs::cti_op_jless): (JSC::JITStubs::cti_op_not): (JSC::JITStubs::cti_op_jtrue): (JSC::JITStubs::cti_op_post_inc): (JSC::JITStubs::cti_op_eq): (JSC::JITStubs::cti_op_lshift): (JSC::JITStubs::cti_op_bitand): (JSC::JITStubs::cti_op_rshift): (JSC::JITStubs::cti_op_bitnot): (JSC::JITStubs::cti_op_resolve_with_base): (JSC::JITStubs::cti_op_new_func_exp): (JSC::JITStubs::cti_op_mod): (JSC::JITStubs::cti_op_less): (JSC::JITStubs::cti_op_neq): (JSC::JITStubs::cti_op_post_dec): (JSC::JITStubs::cti_op_urshift): (JSC::JITStubs::cti_op_bitxor): (JSC::JITStubs::cti_op_new_regexp): (JSC::JITStubs::cti_op_bitor): (JSC::JITStubs::cti_op_call_eval): (JSC::JITStubs::cti_op_throw): (JSC::JITStubs::cti_op_get_pnames): (JSC::JITStubs::cti_op_next_pname): (JSC::JITStubs::cti_op_push_scope): (JSC::JITStubs::cti_op_pop_scope): (JSC::JITStubs::cti_op_typeof): (JSC::JITStubs::cti_op_is_undefined): (JSC::JITStubs::cti_op_is_boolean): (JSC::JITStubs::cti_op_is_number): (JSC::JITStubs::cti_op_is_string): (JSC::JITStubs::cti_op_is_object): (JSC::JITStubs::cti_op_is_function): (JSC::JITStubs::cti_op_stricteq): (JSC::JITStubs::cti_op_to_primitive): (JSC::JITStubs::cti_op_strcat): (JSC::JITStubs::cti_op_nstricteq): (JSC::JITStubs::cti_op_to_jsnumber): (JSC::JITStubs::cti_op_in): (JSC::JITStubs::cti_op_push_new_scope): (JSC::JITStubs::cti_op_jmp_scopes): (JSC::JITStubs::cti_op_put_by_index): (JSC::JITStubs::cti_op_switch_imm): (JSC::JITStubs::cti_op_switch_char): (JSC::JITStubs::cti_op_switch_string): (JSC::JITStubs::cti_op_del_by_val): (JSC::JITStubs::cti_op_put_getter): (JSC::JITStubs::cti_op_put_setter): (JSC::JITStubs::cti_op_new_error): (JSC::JITStubs::cti_op_debug): (JSC::JITStubs::cti_vm_throw):
  • jit/JITStubs.h: (JSC::):
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/jit/JITStubs.cpp

    r43331 r43334  
    221221
    222222#if ENABLE(OPCODE_SAMPLING)
    223     #define CTI_SAMPLER ARG_globalData->interpreter->sampler()
     223    #define CTI_SAMPLER stackFrame.globalData->interpreter->sampler()
    224224#else
    225225    #define CTI_SAMPLER 0
    … …  
    453453    } while (0)
    454454#define VM_THROW_EXCEPTION_AT_END() \
    455     returnToThrowTrampoline(ARG_globalData, STUB_RETURN_ADDRESS, STUB_RETURN_ADDRESS)
     455    returnToThrowTrampoline(stackFrame.globalData, STUB_RETURN_ADDRESS, STUB_RETURN_ADDRESS)
    456456
    457457#define CHECK_FOR_EXCEPTION() \
    458458    do { \
    459         if (UNLIKELY(ARG_globalData->exception != JSValue())) \
     459        if (UNLIKELY(stackFrame.globalData->exception != JSValue())) \
    460460            VM_THROW_EXCEPTION(); \
    461461    } while (0)
    462462#define CHECK_FOR_EXCEPTION_AT_END() \
    463463    do { \
    464         if (UNLIKELY(ARG_globalData->exception != JSValue())) \
     464        if (UNLIKELY(stackFrame.globalData->exception != JSValue())) \
    465465            VM_THROW_EXCEPTION_AT_END(); \
    466466    } while (0)
    467467#define CHECK_FOR_EXCEPTION_VOID() \
    468468    do { \
    469         if (UNLIKELY(ARG_globalData->exception != JSValue())) { \
     469        if (UNLIKELY(stackFrame.globalData->exception != JSValue())) { \
    470470            VM_THROW_EXCEPTION_AT_END(); \
    471471            return; \
    … …  
    473473    } while (0)
    474474
    475 JSObject* JITStubs::cti_op_convert_this(STUB_ARGS)
    476 {
    477     BEGIN_STUB_FUNCTION();
    478 
    479     JSValue v1 = ARG_src1;
    480     CallFrame* callFrame = ARG_callFrame;
     475JSObject* JITStubs::cti_op_convert_this(STUB_ARGS_DECLARATION)
     476{
     477    BEGIN_STUB_FUNCTION();
     478    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     479
     480    JSValue v1 = stackFrame.args[0].jsValue();
     481    CallFrame* callFrame = stackFrame.callFrame;
    481482
    482483    JSObject* result = v1.toThisObject(callFrame);
    … …  
    485486}
    486487
    487 void JITStubs::cti_op_end(STUB_ARGS)
    488 {
    489     BEGIN_STUB_FUNCTION();
    490 
    491     ScopeChainNode* scopeChain = ARG_callFrame->scopeChain();
     488void JITStubs::cti_op_end(STUB_ARGS_DECLARATION)
     489{
     490    BEGIN_STUB_FUNCTION();
     491    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     492
     493    ScopeChainNode* scopeChain = stackFrame.callFrame->scopeChain();
    492494    ASSERT(scopeChain->refCount > 1);
    493495    scopeChain->deref();
    494496}
    495497
    496 EncodedJSValue JITStubs::cti_op_add(STUB_ARGS)
    497 {
    498     BEGIN_STUB_FUNCTION();
    499 
    500     JSValue v1 = ARG_src1;
    501     JSValue v2 = ARG_src2;
     498EncodedJSValue JITStubs::cti_op_add(STUB_ARGS_DECLARATION)
     499{
     500    BEGIN_STUB_FUNCTION();
     501    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     502
     503    JSValue v1 = stackFrame.args[0].jsValue();
     504    JSValue v2 = stackFrame.args[1].jsValue();
    502505
    503506    double left;
    … …  
    506509    bool rightIsNumber = v2.getNumber(right);
    507510    if (rightIsNumber && v1.getNumber(left))
    508         return JSValue::encode(jsNumber(ARG_globalData, left + right));
    509    
    510     CallFrame* callFrame = ARG_callFrame;
     511        return JSValue::encode(jsNumber(stackFrame.globalData, left + right));
     512   
     513    CallFrame* callFrame = stackFrame.callFrame;
    511514
    512515    bool leftIsString = v1.isString();
    … …  
    518521        }
    519522
    520         return JSValue::encode(jsString(ARG_globalData, value.release()));
     523        return JSValue::encode(jsString(stackFrame.globalData, value.release()));
    521524    }
    522525
    … …  
    530533            VM_THROW_EXCEPTION();
    531534        }
    532         return JSValue::encode(jsString(ARG_globalData, value.release()));
     535        return JSValue::encode(jsString(stackFrame.globalData, value.release()));
    533536    }
    534537
    … …  
    539542}
    540543
    541 EncodedJSValue JITStubs::cti_op_pre_inc(STUB_ARGS)
    542 {
    543     BEGIN_STUB_FUNCTION();
    544 
    545     JSValue v = ARG_src1;
    546 
    547     CallFrame* callFrame = ARG_callFrame;
    548     JSValue result = jsNumber(ARG_globalData, v.toNumber(callFrame) + 1);
    549     CHECK_FOR_EXCEPTION_AT_END();
    550     return JSValue::encode(result);
    551 }
    552 
    553 int JITStubs::cti_timeout_check(STUB_ARGS)
    554 {
    555     BEGIN_STUB_FUNCTION();
    556    
    557     JSGlobalData* globalData = ARG_globalData;
     544EncodedJSValue JITStubs::cti_op_pre_inc(STUB_ARGS_DECLARATION)
     545{
     546    BEGIN_STUB_FUNCTION();
     547    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     548
     549    JSValue v = stackFrame.args[0].jsValue();
     550
     551    CallFrame* callFrame = stackFrame.callFrame;
     552    JSValue result = jsNumber(stackFrame.globalData, v.toNumber(callFrame) + 1);
     553    CHECK_FOR_EXCEPTION_AT_END();
     554    return JSValue::encode(result);
     555}
     556
     557int JITStubs::cti_timeout_check(STUB_ARGS_DECLARATION)
     558{
     559    BEGIN_STUB_FUNCTION();
     560    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     561   
     562    JSGlobalData* globalData = stackFrame.globalData;
    558563    TimeoutChecker& timeoutChecker = globalData->timeoutChecker;
    559564
    560     if (timeoutChecker.didTimeOut(ARG_callFrame)) {
     565    if (timeoutChecker.didTimeOut(stackFrame.callFrame)) {
    561566        globalData->exception = createInterruptedExecutionException(globalData);
    562567        VM_THROW_EXCEPTION_AT_END();
    … …  
    566571}
    567572
    568 void JITStubs::cti_register_file_check(STUB_ARGS)
    569 {
    570     BEGIN_STUB_FUNCTION();
    571 
    572     if (LIKELY(ARG_registerFile->grow(ARG_callFrame + ARG_callFrame->codeBlock()->m_numCalleeRegisters)))
     573void JITStubs::cti_register_file_check(STUB_ARGS_DECLARATION)
     574{
     575    BEGIN_STUB_FUNCTION();
     576    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     577
     578    if (LIKELY(stackFrame.registerFile->grow(stackFrame.callFrame + stackFrame.callFrame->codeBlock()->m_numCalleeRegisters)))
    573579        return;
    574580
    575581    // Rewind to the previous call frame because op_call already optimistically
    576582    // moved the call frame forward.
    577     CallFrame* oldCallFrame = ARG_callFrame->callerFrame();
    578     ARG_setCallFrame(oldCallFrame);
    579     throwStackOverflowError(oldCallFrame, ARG_globalData, oldCallFrame->returnPC(), STUB_RETURN_ADDRESS);
    580 }
    581 
    582 int JITStubs::cti_op_loop_if_less(STUB_ARGS)
    583 {
    584     BEGIN_STUB_FUNCTION();
    585 
    586     JSValue src1 = ARG_src1;
    587     JSValue src2 = ARG_src2;
    588     CallFrame* callFrame = ARG_callFrame;
     583    CallFrame* oldCallFrame = stackFrame.callFrame->callerFrame();
     584    stackFrame.callFrame = oldCallFrame;
     585    throwStackOverflowError(oldCallFrame, stackFrame.globalData, oldCallFrame->returnPC(), STUB_RETURN_ADDRESS);
     586}
     587
     588int JITStubs::cti_op_loop_if_less(STUB_ARGS_DECLARATION)
     589{
     590    BEGIN_STUB_FUNCTION();
     591    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     592
     593    JSValue src1 = stackFrame.args[0].jsValue();
     594    JSValue src2 = stackFrame.args[1].jsValue();
     595    CallFrame* callFrame = stackFrame.callFrame;
    589596
    590597    bool result = jsLess(callFrame, src1, src2);
    … …  
    593600}
    594601
    595 int JITStubs::cti_op_loop_if_lesseq(STUB_ARGS)
    596 {
    597     BEGIN_STUB_FUNCTION();
    598 
    599     JSValue src1 = ARG_src1;
    600     JSValue src2 = ARG_src2;
    601     CallFrame* callFrame = ARG_callFrame;
     602int JITStubs::cti_op_loop_if_lesseq(STUB_ARGS_DECLARATION)
     603{
     604    BEGIN_STUB_FUNCTION();
     605    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     606
     607    JSValue src1 = stackFrame.args[0].jsValue();
     608    JSValue src2 = stackFrame.args[1].jsValue();
     609    CallFrame* callFrame = stackFrame.callFrame;
    602610
    603611    bool result = jsLessEq(callFrame, src1, src2);
    … …  
    606614}
    607615
    608 JSObject* JITStubs::cti_op_new_object(STUB_ARGS)
    609 {
    610     BEGIN_STUB_FUNCTION();
    611 
    612     return constructEmptyObject(ARG_callFrame);
    613 }
    614 
    615 void JITStubs::cti_op_put_by_id_generic(STUB_ARGS)
    616 {
    617     BEGIN_STUB_FUNCTION();
     616JSObject* JITStubs::cti_op_new_object(STUB_ARGS_DECLARATION)
     617{
     618    BEGIN_STUB_FUNCTION();
     619    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     620
     621    return constructEmptyObject(stackFrame.callFrame);
     622}
     623
     624void JITStubs::cti_op_put_by_id_generic(STUB_ARGS_DECLARATION)
     625{
     626    BEGIN_STUB_FUNCTION();
     627    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
    618628
    619629    PutPropertySlot slot;
    620     ARG_src1.put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
    621     CHECK_FOR_EXCEPTION_AT_END();
    622 }
    623 
    624 EncodedJSValue JITStubs::cti_op_get_by_id_generic(STUB_ARGS)
    625 {
    626     BEGIN_STUB_FUNCTION();
    627 
    628     CallFrame* callFrame = ARG_callFrame;
    629     Identifier& ident = *ARG_id2;
    630 
    631     JSValue baseValue = ARG_src1;
     630    stackFrame.args[0].jsValue().put(stackFrame.callFrame, stackFrame.args[1].identifier(), stackFrame.args[2].jsValue(), slot);
     631    CHECK_FOR_EXCEPTION_AT_END();
     632}
     633
     634EncodedJSValue JITStubs::cti_op_get_by_id_generic(STUB_ARGS_DECLARATION)
     635{
     636    BEGIN_STUB_FUNCTION();
     637    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     638
     639    CallFrame* callFrame = stackFrame.callFrame;
     640    Identifier& ident = stackFrame.args[1].identifier();
     641
     642    JSValue baseValue = stackFrame.args[0].jsValue();
    632643    PropertySlot slot(baseValue);
    633644    JSValue result = baseValue.get(callFrame, ident, slot);
    … …  
    639650#if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
    640651
    641 void JITStubs::cti_op_put_by_id(STUB_ARGS)
    642 {
    643     BEGIN_STUB_FUNCTION();
    644 
    645     CallFrame* callFrame = ARG_callFrame;
    646     Identifier& ident = *ARG_id2;
     652void JITStubs::cti_op_put_by_id(STUB_ARGS_DECLARATION)
     653{
     654    BEGIN_STUB_FUNCTION();
     655    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     656
     657    CallFrame* callFrame = stackFrame.callFrame;
     658    Identifier& ident = stackFrame.args[1].identifier();
    647659
    648660    PutPropertySlot slot;
    649     ARG_src1.put(callFrame, ident, ARG_src3, slot);
     661    stackFrame.args[0].jsValue().put(callFrame, ident, stackFrame.args[2].jsValue(), slot);
    650662
    651663    ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_put_by_id_second));
    … …  
    654666}
    655667
    656 void JITStubs::cti_op_put_by_id_second(STUB_ARGS)
    657 {
    658     BEGIN_STUB_FUNCTION();
     668void JITStubs::cti_op_put_by_id_second(STUB_ARGS_DECLARATION)
     669{
     670    BEGIN_STUB_FUNCTION();
     671    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
    659672
    660673    PutPropertySlot slot;
    661     ARG_src1.put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
    662     tryCachePutByID(ARG_callFrame, ARG_callFrame->codeBlock(), STUB_RETURN_ADDRESS, ARG_src1, slot);
    663     CHECK_FOR_EXCEPTION_AT_END();
    664 }
    665 
    666 void JITStubs::cti_op_put_by_id_fail(STUB_ARGS)
    667 {
    668     BEGIN_STUB_FUNCTION();
    669 
    670     CallFrame* callFrame = ARG_callFrame;
    671     Identifier& ident = *ARG_id2;
     674    stackFrame.args[0].jsValue().put(stackFrame.callFrame, stackFrame.args[1].identifier(), stackFrame.args[2].jsValue(), slot);
     675    tryCachePutByID(stackFrame.callFrame, stackFrame.callFrame->codeBlock(), STUB_RETURN_ADDRESS, stackFrame.args[0].jsValue(), slot);
     676    CHECK_FOR_EXCEPTION_AT_END();
     677}
     678
     679void JITStubs::cti_op_put_by_id_fail(STUB_ARGS_DECLARATION)
     680{
     681    BEGIN_STUB_FUNCTION();
     682    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     683
     684    CallFrame* callFrame = stackFrame.callFrame;
     685    Identifier& ident = stackFrame.args[1].identifier();
    672686
    673687    PutPropertySlot slot;
    674     ARG_src1.put(callFrame, ident, ARG_src3, slot);
    675 
    676     CHECK_FOR_EXCEPTION_AT_END();
    677 }
    678 
    679 EncodedJSValue JITStubs::cti_op_get_by_id(STUB_ARGS)
    680 {
    681     BEGIN_STUB_FUNCTION();
    682 
    683     CallFrame* callFrame = ARG_callFrame;
    684     Identifier& ident = *ARG_id2;
    685 
    686     JSValue baseValue = ARG_src1;
     688    stackFrame.args[0].jsValue().put(callFrame, ident, stackFrame.args[2].jsValue(), slot);
     689
     690    CHECK_FOR_EXCEPTION_AT_END();
     691}
     692
     693EncodedJSValue JITStubs::cti_op_get_by_id(STUB_ARGS_DECLARATION)
     694{
     695    BEGIN_STUB_FUNCTION();
     696    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     697
     698    CallFrame* callFrame = stackFrame.callFrame;
     699    Identifier& ident = stackFrame.args[1].identifier();
     700
     701    JSValue baseValue = stackFrame.args[0].jsValue();
    687702    PropertySlot slot(baseValue);
    688703    JSValue result = baseValue.get(callFrame, ident, slot);
    … …  
    694709}
    695710
    696 EncodedJSValue JITStubs::cti_op_get_by_id_second(STUB_ARGS)
    697 {
    698     BEGIN_STUB_FUNCTION();
    699 
    700     CallFrame* callFrame = ARG_callFrame;
    701     Identifier& ident = *ARG_id2;
    702 
    703     JSValue baseValue = ARG_src1;
     711EncodedJSValue JITStubs::cti_op_get_by_id_second(STUB_ARGS_DECLARATION)
     712{
     713    BEGIN_STUB_FUNCTION();
     714    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     715
     716    CallFrame* callFrame = stackFrame.callFrame;
     717    Identifier& ident = stackFrame.args[1].identifier();
     718
     719    JSValue baseValue = stackFrame.args[0].jsValue();
    704720    PropertySlot slot(baseValue);
    705721    JSValue result = baseValue.get(callFrame, ident, slot);
    … …  
    711727}
    712728
    713 EncodedJSValue JITStubs::cti_op_get_by_id_self_fail(STUB_ARGS)
    714 {
    715     BEGIN_STUB_FUNCTION();
    716 
    717     CallFrame* callFrame = ARG_callFrame;
    718     Identifier& ident = *ARG_id2;
    719 
    720     JSValue baseValue = ARG_src1;
     729EncodedJSValue JITStubs::cti_op_get_by_id_self_fail(STUB_ARGS_DECLARATION)
     730{
     731    BEGIN_STUB_FUNCTION();
     732    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     733
     734    CallFrame* callFrame = stackFrame.callFrame;
     735    Identifier& ident = stackFrame.args[1].identifier();
     736
     737    JSValue baseValue = stackFrame.args[0].jsValue();
    721738    PropertySlot slot(baseValue);
    722739    JSValue result = baseValue.get(callFrame, ident, slot);
    … …  
    786803}
    787804
    788 EncodedJSValue JITStubs::cti_op_get_by_id_proto_list(STUB_ARGS)
    789 {
    790     BEGIN_STUB_FUNCTION();
    791 
    792     CallFrame* callFrame = ARG_callFrame;
    793 
    794     JSValue baseValue = ARG_src1;
     805EncodedJSValue JITStubs::cti_op_get_by_id_proto_list(STUB_ARGS_DECLARATION)
     806{
     807    BEGIN_STUB_FUNCTION();
     808    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     809
     810    CallFrame* callFrame = stackFrame.callFrame;
     811
     812    JSValue baseValue = stackFrame.args[0].jsValue();
    795813    PropertySlot slot(baseValue);
    796     JSValue result = baseValue.get(callFrame, *ARG_id2, slot);
     814    JSValue result = baseValue.get(callFrame, stackFrame.args[1].identifier(), slot);
    797815
    798816    CHECK_FOR_EXCEPTION();
    … …  
    838856}
    839857
    840 EncodedJSValue JITStubs::cti_op_get_by_id_proto_list_full(STUB_ARGS)
    841 {
    842     BEGIN_STUB_FUNCTION();
    843 
    844     JSValue baseValue = ARG_src1;
     858EncodedJSValue JITStubs::cti_op_get_by_id_proto_list_full(STUB_ARGS_DECLARATION)
     859{
     860    BEGIN_STUB_FUNCTION();
     861    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     862
     863    JSValue baseValue = stackFrame.args[0].jsValue();
    845864    PropertySlot slot(baseValue);
    846     JSValue result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
    847 
    848     CHECK_FOR_EXCEPTION_AT_END();
    849     return JSValue::encode(result);
    850 }
    851 
    852 EncodedJSValue JITStubs::cti_op_get_by_id_proto_fail(STUB_ARGS)
    853 {
    854     BEGIN_STUB_FUNCTION();
    855 
    856     JSValue baseValue = ARG_src1;
     865    JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
     866
     867    CHECK_FOR_EXCEPTION_AT_END();
     868    return JSValue::encode(result);
     869}
     870
     871EncodedJSValue JITStubs::cti_op_get_by_id_proto_fail(STUB_ARGS_DECLARATION)
     872{
     873    BEGIN_STUB_FUNCTION();
     874    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     875
     876    JSValue baseValue = stackFrame.args[0].jsValue();
    857877    PropertySlot slot(baseValue);
    858     JSValue result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
    859 
    860     CHECK_FOR_EXCEPTION_AT_END();
    861     return JSValue::encode(result);
    862 }
    863 
    864 EncodedJSValue JITStubs::cti_op_get_by_id_array_fail(STUB_ARGS)
    865 {
    866     BEGIN_STUB_FUNCTION();
    867 
    868     JSValue baseValue = ARG_src1;
     878    JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
     879
     880    CHECK_FOR_EXCEPTION_AT_END();
     881    return JSValue::encode(result);
     882}
     883
     884EncodedJSValue JITStubs::cti_op_get_by_id_array_fail(STUB_ARGS_DECLARATION)
     885{
     886    BEGIN_STUB_FUNCTION();
     887    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     888
     889    JSValue baseValue = stackFrame.args[0].jsValue();
    869890    PropertySlot slot(baseValue);
    870     JSValue result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
    871 
    872     CHECK_FOR_EXCEPTION_AT_END();
    873     return JSValue::encode(result);
    874 }
    875 
    876 EncodedJSValue JITStubs::cti_op_get_by_id_string_fail(STUB_ARGS)
    877 {
    878     BEGIN_STUB_FUNCTION();
    879 
    880     JSValue baseValue = ARG_src1;
     891    JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
     892
     893    CHECK_FOR_EXCEPTION_AT_END();
     894    return JSValue::encode(result);
     895}
     896
     897EncodedJSValue JITStubs::cti_op_get_by_id_string_fail(STUB_ARGS_DECLARATION)
     898{
     899    BEGIN_STUB_FUNCTION();
     900    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     901
     902    JSValue baseValue = stackFrame.args[0].jsValue();
    881903    PropertySlot slot(baseValue);
    882     JSValue result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
     904    JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
    883905
    884906    CHECK_FOR_EXCEPTION_AT_END();
    … …  
    888910#endif
    889911
    890 EncodedJSValue JITStubs::cti_op_instanceof(STUB_ARGS)
    891 {
    892     BEGIN_STUB_FUNCTION();
    893 
    894     CallFrame* callFrame = ARG_callFrame;
    895     JSValue value = ARG_src1;
    896     JSValue baseVal = ARG_src2;
    897     JSValue proto = ARG_src3;
     912EncodedJSValue JITStubs::cti_op_instanceof(STUB_ARGS_DECLARATION)
     913{
     914    BEGIN_STUB_FUNCTION();
     915    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     916
     917    CallFrame* callFrame = stackFrame.callFrame;
     918    JSValue value = stackFrame.args[0].jsValue();
     919    JSValue baseVal = stackFrame.args[1].jsValue();
     920    JSValue proto = stackFrame.args[2].jsValue();
    898921
    899922    // at least one of these checks must have failed to get to the slow case
    … …  
    903926
    904927    if (!baseVal.isObject()) {
    905         CallFrame* callFrame = ARG_callFrame;
     928        CallFrame* callFrame = stackFrame.callFrame;
    906929        CodeBlock* codeBlock = callFrame->codeBlock();
    907930        unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    908         ARG_globalData->exception = createInvalidParamError(callFrame, "instanceof", baseVal, vPCIndex, codeBlock);
     931        stackFrame.globalData->exception = createInvalidParamError(callFrame, "instanceof", baseVal, vPCIndex, codeBlock);
    909932        VM_THROW_EXCEPTION();
    910933    }
    … …  
    931954}
    932955
    933 EncodedJSValue JITStubs::cti_op_del_by_id(STUB_ARGS)
    934 {
    935     BEGIN_STUB_FUNCTION();
    936 
    937     CallFrame* callFrame = ARG_callFrame;
    938    
    939     JSObject* baseObj = ARG_src1.toObject(callFrame);
    940 
    941     JSValue result = jsBoolean(baseObj->deleteProperty(callFrame, *ARG_id2));
    942     CHECK_FOR_EXCEPTION_AT_END();
    943     return JSValue::encode(result);
    944 }
    945 
    946 EncodedJSValue JITStubs::cti_op_mul(STUB_ARGS)
    947 {
    948     BEGIN_STUB_FUNCTION();
    949 
    950     JSValue src1 = ARG_src1;
    951     JSValue src2 = ARG_src2;
     956EncodedJSValue JITStubs::cti_op_del_by_id(STUB_ARGS_DECLARATION)
     957{
     958    BEGIN_STUB_FUNCTION();
     959    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     960
     961    CallFrame* callFrame = stackFrame.callFrame;
     962   
     963    JSObject* baseObj = stackFrame.args[0].jsValue().toObject(callFrame);
     964
     965    JSValue result = jsBoolean(baseObj->deleteProperty(callFrame, stackFrame.args[1].identifier()));
     966    CHECK_FOR_EXCEPTION_AT_END();
     967    return JSValue::encode(result);
     968}
     969
     970EncodedJSValue JITStubs::cti_op_mul(STUB_ARGS_DECLARATION)
     971{
     972    BEGIN_STUB_FUNCTION();
     973    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     974
     975    JSValue src1 = stackFrame.args[0].jsValue();
     976    JSValue src2 = stackFrame.args[1].jsValue();
    952977
    953978    double left;
    954979    double right;
    955980    if (src1.getNumber(left) && src2.getNumber(right))
    956         return JSValue::encode(jsNumber(ARG_globalData, left * right));
    957 
    958     CallFrame* callFrame = ARG_callFrame;
    959     JSValue result = jsNumber(ARG_globalData, src1.toNumber(callFrame) * src2.toNumber(callFrame));
    960     CHECK_FOR_EXCEPTION_AT_END();
    961     return JSValue::encode(result);
    962 }
    963 
    964 JSObject* JITStubs::cti_op_new_func(STUB_ARGS)
    965 {
    966     BEGIN_STUB_FUNCTION();
    967 
    968     return ARG_func1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
    969 }
    970 
    971 void* JITStubs::cti_op_call_JSFunction(STUB_ARGS)
    972 {
    973     BEGIN_STUB_FUNCTION();
     981        return JSValue::encode(jsNumber(stackFrame.globalData, left * right));
     982
     983    CallFrame* callFrame = stackFrame.callFrame;
     984    JSValue result = jsNumber(stackFrame.globalData, src1.toNumber(callFrame) * src2.toNumber(callFrame));
     985    CHECK_FOR_EXCEPTION_AT_END();
     986    return JSValue::encode(result);
     987}
     988
     989JSObject* JITStubs::cti_op_new_func(STUB_ARGS_DECLARATION)
     990{
     991    BEGIN_STUB_FUNCTION();
     992    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     993
     994    return stackFrame.args[0].funcDeclNode()->makeFunction(stackFrame.callFrame, stackFrame.callFrame->scopeChain());
     995}
     996
     997void* JITStubs::cti_op_call_JSFunction(STUB_ARGS_DECLARATION)
     998{
     999    BEGIN_STUB_FUNCTION();
     1000    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
    9741001
    9751002#ifndef NDEBUG
    9761003    CallData callData;
    977     ASSERT(ARG_src1.getCallData(callData) == CallTypeJS);
     1004    ASSERT(stackFrame.args[0].jsValue().getCallData(callData) == CallTypeJS);
    9781005#endif
    9791006
    980     JSFunction* function = asFunction(ARG_src1);
     1007    JSFunction* function = asFunction(stackFrame.args[0].jsValue());
    9811008    FunctionBodyNode* body = function->body();
    9821009    ScopeChainNode* callDataScopeChain = function->scope().node();
    … …  
    9861013}
    9871014
    988 VoidPtrPair JITStubs::cti_op_call_arityCheck(STUB_ARGS)
    989 {
    990     BEGIN_STUB_FUNCTION();
    991 
    992     CallFrame* callFrame = ARG_callFrame;
    993     CodeBlock* newCodeBlock = ARG_codeBlock4;
    994     int argCount = ARG_int3;
     1015VoidPtrPair JITStubs::cti_op_call_arityCheck(STUB_ARGS_DECLARATION)
     1016{
     1017    BEGIN_STUB_FUNCTION();
     1018    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1019
     1020    CallFrame* callFrame = stackFrame.callFrame;
     1021    CodeBlock* newCodeBlock = stackFrame.args[3].codeBlock();
     1022    int argCount = stackFrame.args[2].int32();
    9951023
    9961024    ASSERT(argCount != newCodeBlock->m_numParameters);
    … …  
    10121040        Register* r = callFrame->registers() + omittedArgCount;
    10131041        Register* newEnd = r + newCodeBlock->m_numCalleeRegisters;
    1014         if (!ARG_registerFile->grow(newEnd)) {
     1042        if (!stackFrame.registerFile->grow(newEnd)) {
    10151043            // Rewind to the previous call frame because op_call already optimistically
    10161044            // moved the call frame forward.
    1017             ARG_setCallFrame(oldCallFrame);
    1018             throwStackOverflowError(oldCallFrame, ARG_globalData, ARG_returnAddress2, STUB_RETURN_ADDRESS);
     1045            stackFrame.callFrame = oldCallFrame;
     1046            throwStackOverflowError(oldCallFrame, stackFrame.globalData, stackFrame.args[1].returnAddress(), STUB_RETURN_ADDRESS);
    10191047            RETURN_PAIR(0, 0);
    10201048        }
    … …  
    10311059}
    10321060
    1033 void* JITStubs::cti_vm_dontLazyLinkCall(STUB_ARGS)
    1034 {
    1035     BEGIN_STUB_FUNCTION();
    1036 
    1037     JSGlobalData* globalData = ARG_globalData;
    1038     JSFunction* callee = asFunction(ARG_src1);
     1061void* JITStubs::cti_vm_dontLazyLinkCall(STUB_ARGS_DECLARATION)
     1062{
     1063    BEGIN_STUB_FUNCTION();
     1064    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1065
     1066    JSGlobalData* globalData = stackFrame.globalData;
     1067    JSFunction* callee = asFunction(stackFrame.args[0].jsValue());
    10391068    JITCode jitCode = callee->body()->generatedJITCode();
    10401069    ASSERT(jitCode);
    10411070
    1042     ctiPatchNearCallByReturnAddress(ARG_returnAddress2, globalData->jitStubs.ctiVirtualCallLink());
     1071    ctiPatchNearCallByReturnAddress(stackFrame.args[1].returnAddress(), globalData->jitStubs.ctiVirtualCallLink());
    10431072
    10441073    return jitCode.addressForCall();
    10451074}
    10461075
    1047 void* JITStubs::cti_vm_lazyLinkCall(STUB_ARGS)
    1048 {
    1049     BEGIN_STUB_FUNCTION();
    1050 
    1051     JSFunction* callee = asFunction(ARG_src1);
     1076void* JITStubs::cti_vm_lazyLinkCall(STUB_ARGS_DECLARATION)
     1077{
     1078    BEGIN_STUB_FUNCTION();
     1079    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1080
     1081    JSFunction* callee = asFunction(stackFrame.args[0].jsValue());
    10521082    JITCode jitCode = callee->body()->generatedJITCode();
    10531083    ASSERT(jitCode);
    … …  
    10571087        codeBlock = &callee->body()->bytecode(callee->scope().node());
    10581088
    1059     CallLinkInfo* callLinkInfo = &ARG_callFrame->callerFrame()->codeBlock()->getCallLinkInfo(ARG_returnAddress2);
    1060     JIT::linkCall(callee, codeBlock, jitCode, callLinkInfo, ARG_int3);
     1089    CallLinkInfo* callLinkInfo = &stackFrame.callFrame->callerFrame()->codeBlock()->getCallLinkInfo(stackFrame.args[1].returnAddress());
     1090    JIT::linkCall(callee, codeBlock, jitCode, callLinkInfo, stackFrame.args[2].int32());
    10611091
    10621092    return jitCode.addressForCall();
    10631093}
    10641094
    1065 JSObject* JITStubs::cti_op_push_activation(STUB_ARGS)
    1066 {
    1067     BEGIN_STUB_FUNCTION();
    1068 
    1069     JSActivation* activation = new (ARG_globalData) JSActivation(ARG_callFrame, static_cast<FunctionBodyNode*>(ARG_callFrame->codeBlock()->ownerNode()));
    1070     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->copy()->push(activation));
     1095JSObject* JITStubs::cti_op_push_activation(STUB_ARGS_DECLARATION)
     1096{
     1097    BEGIN_STUB_FUNCTION();
     1098    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1099
     1100    JSActivation* activation = new (stackFrame.globalData) JSActivation(stackFrame.callFrame, static_cast<FunctionBodyNode*>(stackFrame.callFrame->codeBlock()->ownerNode()));
     1101    stackFrame.callFrame->setScopeChain(stackFrame.callFrame->scopeChain()->copy()->push(activation));
    10711102    return activation;
    10721103}
    10731104
    1074 EncodedJSValue JITStubs::cti_op_call_NotJSFunction(STUB_ARGS)
    1075 {
    1076     BEGIN_STUB_FUNCTION();
    1077 
    1078     JSValue funcVal = ARG_src1;
     1105EncodedJSValue JITStubs::cti_op_call_NotJSFunction(STUB_ARGS_DECLARATION)
     1106{
     1107    BEGIN_STUB_FUNCTION();
     1108    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1109
     1110    JSValue funcVal = stackFrame.args[0].jsValue();
    10791111
    10801112    CallData callData;
    … …  
    10841116
    10851117    if (callType == CallTypeHost) {
    1086         int registerOffset = ARG_int2;
    1087         int argCount = ARG_int3;
    1088         CallFrame* previousCallFrame = ARG_callFrame;
     1118        int registerOffset = stackFrame.args[1].int32();
     1119        int argCount = stackFrame.args[2].int32();
     1120        CallFrame* previousCallFrame = stackFrame.callFrame;
    10891121        CallFrame* callFrame = CallFrame::create(previousCallFrame->registers() + registerOffset);
    10901122
    10911123        callFrame->init(0, static_cast<Instruction*>(STUB_RETURN_ADDRESS), previousCallFrame->scopeChain(), previousCallFrame, 0, argCount, 0);
    1092         ARG_setCallFrame(callFrame);
    1093 
    1094         Register* argv = ARG_callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
     1124        stackFrame.callFrame = callFrame;
     1125
     1126        Register* argv = stackFrame.callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
    10951127        ArgList argList(argv + 1, argCount - 1);
    10961128
    … …  
    11061138            returnValue = callData.native.function(callFrame, asObject(funcVal), thisValue, argList);
    11071139        }
    1108         ARG_setCallFrame(previousCallFrame);
     1140        stackFrame.callFrame = previousCallFrame;
    11091141        CHECK_FOR_EXCEPTION();
    11101142
    … …  
    11141146    ASSERT(callType == CallTypeNone);
    11151147
    1116     CallFrame* callFrame = ARG_callFrame;
     1148    CallFrame* callFrame = stackFrame.callFrame;
    11171149    CodeBlock* codeBlock = callFrame->codeBlock();
    11181150    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1119     ARG_globalData->exception = createNotAFunctionError(ARG_callFrame, funcVal, vPCIndex, codeBlock);
     1151    stackFrame.globalData->exception = createNotAFunctionError(stackFrame.callFrame, funcVal, vPCIndex, codeBlock);
    11201152    VM_THROW_EXCEPTION();
    11211153}
    11221154
    1123 void JITStubs::cti_op_create_arguments(STUB_ARGS)
    1124 {
    1125     BEGIN_STUB_FUNCTION();
    1126 
    1127     Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame);
    1128     ARG_callFrame->setCalleeArguments(arguments);
    1129     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
    1130 }
    1131 
    1132 void JITStubs::cti_op_create_arguments_no_params(STUB_ARGS)
    1133 {
    1134     BEGIN_STUB_FUNCTION();
    1135 
    1136     Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame, Arguments::NoParameters);
    1137     ARG_callFrame->setCalleeArguments(arguments);
    1138     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
    1139 }
    1140 
    1141 void JITStubs::cti_op_tear_off_activation(STUB_ARGS)
    1142 {
    1143     BEGIN_STUB_FUNCTION();
    1144 
    1145     ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain());
    1146     asActivation(ARG_src1)->copyRegisters(ARG_callFrame->optionalCalleeArguments());
    1147 }
    1148 
    1149 void JITStubs::cti_op_tear_off_arguments(STUB_ARGS)
    1150 {
    1151     BEGIN_STUB_FUNCTION();
    1152 
    1153     ASSERT(ARG_callFrame->codeBlock()->usesArguments() && !ARG_callFrame->codeBlock()->needsFullScopeChain());
    1154     ARG_callFrame->optionalCalleeArguments()->copyRegisters();
    1155 }
    1156 
    1157 void JITStubs::cti_op_profile_will_call(STUB_ARGS)
    1158 {
    1159     BEGIN_STUB_FUNCTION();
    1160 
    1161     ASSERT(*ARG_profilerReference);
    1162     (*ARG_profilerReference)->willExecute(ARG_callFrame, ARG_src1);
    1163 }
    1164 
    1165 void JITStubs::cti_op_profile_did_call(STUB_ARGS)
    1166 {
    1167     BEGIN_STUB_FUNCTION();
    1168 
    1169     ASSERT(*ARG_profilerReference);
    1170     (*ARG_profilerReference)->didExecute(ARG_callFrame, ARG_src1);
    1171 }
    1172 
    1173 void JITStubs::cti_op_ret_scopeChain(STUB_ARGS)
    1174 {
    1175     BEGIN_STUB_FUNCTION();
    1176 
    1177     ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain());
    1178     ARG_callFrame->scopeChain()->deref();
    1179 }
    1180 
    1181 JSObject* JITStubs::cti_op_new_array(STUB_ARGS)
    1182 {
    1183     BEGIN_STUB_FUNCTION();
    1184 
    1185     ArgList argList(&ARG_callFrame->registers()[ARG_int1], ARG_int2);
    1186     return constructArray(ARG_callFrame, argList);
    1187 }
    1188 
    1189 EncodedJSValue JITStubs::cti_op_resolve(STUB_ARGS)
    1190 {
    1191     BEGIN_STUB_FUNCTION();
    1192 
    1193     CallFrame* callFrame = ARG_callFrame;
     1155void JITStubs::cti_op_create_arguments(STUB_ARGS_DECLARATION)
     1156{
     1157    BEGIN_STUB_FUNCTION();
     1158    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1159
     1160    Arguments* arguments = new (stackFrame.globalData) Arguments(stackFrame.callFrame);
     1161    stackFrame.callFrame->setCalleeArguments(arguments);
     1162    stackFrame.callFrame[RegisterFile::ArgumentsRegister] = arguments;
     1163}
     1164
     1165void JITStubs::cti_op_create_arguments_no_params(STUB_ARGS_DECLARATION)
     1166{
     1167    BEGIN_STUB_FUNCTION();
     1168    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1169
     1170    Arguments* arguments = new (stackFrame.globalData) Arguments(stackFrame.callFrame, Arguments::NoParameters);
     1171    stackFrame.callFrame->setCalleeArguments(arguments);
     1172    stackFrame.callFrame[RegisterFile::ArgumentsRegister] = arguments;
     1173}
     1174
     1175void JITStubs::cti_op_tear_off_activation(STUB_ARGS_DECLARATION)
     1176{
     1177    BEGIN_STUB_FUNCTION();
     1178    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1179
     1180    ASSERT(stackFrame.callFrame->codeBlock()->needsFullScopeChain());
     1181    asActivation(stackFrame.args[0].jsValue())->copyRegisters(stackFrame.callFrame->optionalCalleeArguments());
     1182}
     1183
     1184void JITStubs::cti_op_tear_off_arguments(STUB_ARGS_DECLARATION)
     1185{
     1186    BEGIN_STUB_FUNCTION();
     1187    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1188
     1189    ASSERT(stackFrame.callFrame->codeBlock()->usesArguments() && !stackFrame.callFrame->codeBlock()->needsFullScopeChain());
     1190    stackFrame.callFrame->optionalCalleeArguments()->copyRegisters();
     1191}
     1192
     1193void JITStubs::cti_op_profile_will_call(STUB_ARGS_DECLARATION)
     1194{
     1195    BEGIN_STUB_FUNCTION();
     1196    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1197
     1198    ASSERT(*stackFrame.enabledProfilerReference);
     1199    (*stackFrame.enabledProfilerReference)->willExecute(stackFrame.callFrame, stackFrame.args[0].jsValue());
     1200}
     1201
     1202void JITStubs::cti_op_profile_did_call(STUB_ARGS_DECLARATION)
     1203{
     1204    BEGIN_STUB_FUNCTION();
     1205    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1206
     1207    ASSERT(*stackFrame.enabledProfilerReference);
     1208    (*stackFrame.enabledProfilerReference)->didExecute(stackFrame.callFrame, stackFrame.args[0].jsValue());
     1209}
     1210
     1211void JITStubs::cti_op_ret_scopeChain(STUB_ARGS_DECLARATION)
     1212{
     1213    BEGIN_STUB_FUNCTION();
     1214    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1215
     1216    ASSERT(stackFrame.callFrame->codeBlock()->needsFullScopeChain());
     1217    stackFrame.callFrame->scopeChain()->deref();
     1218}
     1219
     1220JSObject* JITStubs::cti_op_new_array(STUB_ARGS_DECLARATION)
     1221{
     1222    BEGIN_STUB_FUNCTION();
     1223    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1224
     1225    ArgList argList(&stackFrame.callFrame->registers()[stackFrame.args[0].int32()], stackFrame.args[1].int32());
     1226    return constructArray(stackFrame.callFrame, argList);
     1227}
     1228
     1229EncodedJSValue JITStubs::cti_op_resolve(STUB_ARGS_DECLARATION)
     1230{
     1231    BEGIN_STUB_FUNCTION();
     1232    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1233
     1234    CallFrame* callFrame = stackFrame.callFrame;
    11941235    ScopeChainNode* scopeChain = callFrame->scopeChain();
    11951236
    … …  
    11981239    ASSERT(iter != end);
    11991240
    1200     Identifier& ident = *ARG_id1;
     1241    Identifier& ident = stackFrame.args[0].identifier();
    12011242    do {
    12021243        JSObject* o = *iter;
    … …  
    12111252    CodeBlock* codeBlock = callFrame->codeBlock();
    12121253    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1213     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     1254    stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
    12141255    VM_THROW_EXCEPTION();
    12151256}
    12161257
    1217 JSObject* JITStubs::cti_op_construct_JSConstruct(STUB_ARGS)
    1218 {
    1219     BEGIN_STUB_FUNCTION();
    1220 
    1221     JSFunction* constructor = asFunction(ARG_src1);
     1258JSObject* JITStubs::cti_op_construct_JSConstruct(STUB_ARGS_DECLARATION)
     1259{
     1260    BEGIN_STUB_FUNCTION();
     1261    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1262
     1263    JSFunction* constructor = asFunction(stackFrame.args[0].jsValue());
    12221264    if (constructor->isHostFunction()) {
    1223         CallFrame* callFrame = ARG_callFrame;
     1265        CallFrame* callFrame = stackFrame.callFrame;
    12241266        CodeBlock* codeBlock = callFrame->codeBlock();
    12251267        unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1226         ARG_globalData->exception = createNotAConstructorError(callFrame, constructor, vPCIndex, codeBlock);
     1268        stackFrame.globalData->exception = createNotAConstructorError(callFrame, constructor, vPCIndex, codeBlock);
    12271269        VM_THROW_EXCEPTION();
    12281270    }
    … …  
    12341276
    12351277    Structure* structure;
    1236     if (ARG_src4.isObject())
    1237         structure = asObject(ARG_src4)->inheritorID();
     1278    if (stackFrame.args[3].jsValue().isObject())
     1279        structure = asObject(stackFrame.args[3].jsValue())->inheritorID();
    12381280    else
    12391281        structure = constructor->scope().node()->globalObject()->emptyObjectStructure();
    1240     return new (ARG_globalData) JSObject(structure);
    1241 }
    1242 
    1243 EncodedJSValue JITStubs::cti_op_construct_NotJSConstruct(STUB_ARGS)
    1244 {
    1245     BEGIN_STUB_FUNCTION();
    1246 
    1247     CallFrame* callFrame = ARG_callFrame;
    1248 
    1249     JSValue constrVal = ARG_src1;
    1250     int argCount = ARG_int3;
    1251     int thisRegister = ARG_int5;
     1282    return new (stackFrame.globalData) JSObject(structure);
     1283}
     1284
     1285EncodedJSValue JITStubs::cti_op_construct_NotJSConstruct(STUB_ARGS_DECLARATION)
     1286{
     1287    BEGIN_STUB_FUNCTION();
     1288    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1289
     1290    CallFrame* callFrame = stackFrame.callFrame;
     1291
     1292    JSValue constrVal = stackFrame.args[0].jsValue();
     1293    int argCount = stackFrame.args[2].int32();
     1294    int thisRegister = stackFrame.args[4].int32();
    12521295
    12531296    ConstructData constructData;
    … …  
    12711314    CodeBlock* codeBlock = callFrame->codeBlock();
    12721315    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1273     ARG_globalData->exception = createNotAConstructorError(callFrame, constrVal, vPCIndex, codeBlock);
     1316    stackFrame.globalData->exception = createNotAConstructorError(callFrame, constrVal, vPCIndex, codeBlock);
    12741317    VM_THROW_EXCEPTION();
    12751318}
    12761319
    1277 EncodedJSValue JITStubs::cti_op_get_by_val(STUB_ARGS)
    1278 {
    1279     BEGIN_STUB_FUNCTION();
    1280 
    1281     CallFrame* callFrame = ARG_callFrame;
    1282     JSGlobalData* globalData = ARG_globalData;
    1283 
    1284     JSValue baseValue = ARG_src1;
    1285     JSValue subscript = ARG_src2;
     1320EncodedJSValue JITStubs::cti_op_get_by_val(STUB_ARGS_DECLARATION)
     1321{
     1322    BEGIN_STUB_FUNCTION();
     1323    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1324
     1325    CallFrame* callFrame = stackFrame.callFrame;
     1326    JSGlobalData* globalData = stackFrame.globalData;
     1327
     1328    JSValue baseValue = stackFrame.args[0].jsValue();
     1329    JSValue subscript = stackFrame.args[1].jsValue();
    12861330
    12871331    JSValue result;
    … …  
    12981342            // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
    12991343            ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_val_string));
    1300             result = asString(baseValue)->getIndex(ARG_globalData, i);
     1344            result = asString(baseValue)->getIndex(stackFrame.globalData, i);
    13011345        } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
    13021346            // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
    … …  
    13141358}
    13151359   
    1316     EncodedJSValue JITStubs::cti_op_get_by_val_string(STUB_ARGS)
    1317     {
    1318         BEGIN_STUB_FUNCTION();
    1319        
    1320         CallFrame* callFrame = ARG_callFrame;
    1321         JSGlobalData* globalData = ARG_globalData;
    1322        
    1323         JSValue baseValue = ARG_src1;
    1324         JSValue subscript = ARG_src2;
    1325        
    1326         JSValue result;
    1327        
    1328         if (LIKELY(subscript.isUInt32Fast())) {
    1329             uint32_t i = subscript.getUInt32Fast();
    1330             if (isJSString(globalData, baseValue) && asString(baseValue)->canGetIndex(i))
    1331                 result = asString(baseValue)->getIndex(ARG_globalData, i);
    1332             else {
    1333                 result = baseValue.get(callFrame, i);
    1334                 if (!isJSString(globalData, baseValue))
    1335                     ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_val));
    1336             }
    1337         } else {
    1338             Identifier property(callFrame, subscript.toString(callFrame));
    1339             result = baseValue.get(callFrame, property);
     1360EncodedJSValue JITStubs::cti_op_get_by_val_string(STUB_ARGS_DECLARATION)
     1361{
     1362    BEGIN_STUB_FUNCTION();
     1363    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1364   
     1365    CallFrame* callFrame = stackFrame.callFrame;
     1366    JSGlobalData* globalData = stackFrame.globalData;
     1367   
     1368    JSValue baseValue = stackFrame.args[0].jsValue();
     1369    JSValue subscript = stackFrame.args[1].jsValue();
     1370   
     1371    JSValue result;
     1372   
     1373    if (LIKELY(subscript.isUInt32Fast())) {
     1374        uint32_t i = subscript.getUInt32Fast();
     1375        if (isJSString(globalData, baseValue) && asString(baseValue)->canGetIndex(i))
     1376            result = asString(baseValue)->getIndex(stackFrame.globalData, i);
     1377        else {
     1378            result = baseValue.get(callFrame, i);
     1379            if (!isJSString(globalData, baseValue))
     1380                ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_val));
    13401381        }
    1341        
    1342         CHECK_FOR_EXCEPTION_AT_END();
    1343         return JSValue::encode(result);
    1344     }
    1345    
    1346 
    1347 EncodedJSValue JITStubs::cti_op_get_by_val_byte_array(STUB_ARGS)
    1348 {
    1349     BEGIN_STUB_FUNCTION();
    1350    
    1351     CallFrame* callFrame = ARG_callFrame;
    1352     JSGlobalData* globalData = ARG_globalData;
    1353    
    1354     JSValue baseValue = ARG_src1;
    1355     JSValue subscript = ARG_src2;
     1382    } else {
     1383        Identifier property(callFrame, subscript.toString(callFrame));
     1384        result = baseValue.get(callFrame, property);
     1385    }
     1386   
     1387    CHECK_FOR_EXCEPTION_AT_END();
     1388    return JSValue::encode(result);
     1389}
     1390   
     1391
     1392EncodedJSValue JITStubs::cti_op_get_by_val_byte_array(STUB_ARGS_DECLARATION)
     1393{
     1394    BEGIN_STUB_FUNCTION();
     1395    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1396   
     1397    CallFrame* callFrame = stackFrame.callFrame;
     1398    JSGlobalData* globalData = stackFrame.globalData;
     1399   
     1400    JSValue baseValue = stackFrame.args[0].jsValue();
     1401    JSValue subscript = stackFrame.args[1].jsValue();
    13561402   
    13571403    JSValue result;
    … …  
    13761422}
    13771423
    1378 VoidPtrPair JITStubs::cti_op_resolve_func(STUB_ARGS)
    1379 {
    1380     BEGIN_STUB_FUNCTION();
    1381 
    1382     CallFrame* callFrame = ARG_callFrame;
     1424VoidPtrPair JITStubs::cti_op_resolve_func(STUB_ARGS_DECLARATION)
     1425{
     1426    BEGIN_STUB_FUNCTION();
     1427    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1428
     1429    CallFrame* callFrame = stackFrame.callFrame;
    13831430    ScopeChainNode* scopeChain = callFrame->scopeChain();
    13841431
    … …  
    13901437    ASSERT(iter != end);
    13911438
    1392     Identifier& ident = *ARG_id1;
     1439    Identifier& ident = stackFrame.args[0].identifier();
    13931440    JSObject* base;
    13941441    do {
    … …  
    14141461    CodeBlock* codeBlock = callFrame->codeBlock();
    14151462    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1416     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     1463    stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
    14171464    VM_THROW_EXCEPTION_2();
    14181465}
    14191466
    1420 EncodedJSValue JITStubs::cti_op_sub(STUB_ARGS)
    1421 {
    1422     BEGIN_STUB_FUNCTION();
    1423 
    1424     JSValue src1 = ARG_src1;
    1425     JSValue src2 = ARG_src2;
     1467EncodedJSValue JITStubs::cti_op_sub(STUB_ARGS_DECLARATION)
     1468{
     1469    BEGIN_STUB_FUNCTION();
     1470    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1471
     1472    JSValue src1 = stackFrame.args[0].jsValue();
     1473    JSValue src2 = stackFrame.args[1].jsValue();
    14261474
    14271475    double left;
    14281476    double right;
    14291477    if (src1.getNumber(left) && src2.getNumber(right))
    1430         return JSValue::encode(jsNumber(ARG_globalData, left - right));
    1431 
    1432     CallFrame* callFrame = ARG_callFrame;
    1433     JSValue result = jsNumber(ARG_globalData, src1.toNumber(callFrame) - src2.toNumber(callFrame));
    1434     CHECK_FOR_EXCEPTION_AT_END();
    1435     return JSValue::encode(result);
    1436 }
    1437 
    1438 void JITStubs::cti_op_put_by_val(STUB_ARGS)
    1439 {
    1440     BEGIN_STUB_FUNCTION();
    1441 
    1442     CallFrame* callFrame = ARG_callFrame;
    1443     JSGlobalData* globalData = ARG_globalData;
    1444 
    1445     JSValue baseValue = ARG_src1;
    1446     JSValue subscript = ARG_src2;
    1447     JSValue value = ARG_src3;
     1478        return JSValue::encode(jsNumber(stackFrame.globalData, left - right));
     1479
     1480    CallFrame* callFrame = stackFrame.callFrame;
     1481    JSValue result = jsNumber(stackFrame.globalData, src1.toNumber(callFrame) - src2.toNumber(callFrame));
     1482    CHECK_FOR_EXCEPTION_AT_END();
     1483    return JSValue::encode(result);
     1484}
     1485
     1486void JITStubs::cti_op_put_by_val(STUB_ARGS_DECLARATION)
     1487{
     1488    BEGIN_STUB_FUNCTION();
     1489    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1490
     1491    CallFrame* callFrame = stackFrame.callFrame;
     1492    JSGlobalData* globalData = stackFrame.globalData;
     1493
     1494    JSValue baseValue = stackFrame.args[0].jsValue();
     1495    JSValue subscript = stackFrame.args[1].jsValue();
     1496    JSValue value = stackFrame.args[2].jsValue();
    14481497
    14491498    if (LIKELY(subscript.isUInt32Fast())) {
    … …  
    14751524    } else {
    14761525        Identifier property(callFrame, subscript.toString(callFrame));
    1477         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
     1526        if (!stackFrame.globalData->exception) { // Don't put to an object if toString threw an exception.
    14781527            PutPropertySlot slot;
    14791528            baseValue.put(callFrame, property, value, slot);
    … …  
    14841533}
    14851534
    1486 void JITStubs::cti_op_put_by_val_array(STUB_ARGS)
    1487 {
    1488     BEGIN_STUB_FUNCTION();
    1489 
    1490     CallFrame* callFrame = ARG_callFrame;
    1491     JSValue baseValue = ARG_src1;
    1492     int i = ARG_int2;
    1493     JSValue value = ARG_src3;
    1494 
    1495     ASSERT(isJSArray(ARG_globalData, baseValue));
     1535void JITStubs::cti_op_put_by_val_array(STUB_ARGS_DECLARATION)
     1536{
     1537    BEGIN_STUB_FUNCTION();
     1538    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1539
     1540    CallFrame* callFrame = stackFrame.callFrame;
     1541    JSValue baseValue = stackFrame.args[0].jsValue();
     1542    int i = stackFrame.args[1].int32();
     1543    JSValue value = stackFrame.args[2].jsValue();
     1544
     1545    ASSERT(isJSArray(stackFrame.globalData, baseValue));
    14961546
    14971547    if (LIKELY(i >= 0))
    … …  
    15021552        Identifier property(callFrame, JSValue::makeInt32Fast(i).toString(callFrame));
    15031553        // FIXME: can toString throw an exception here?
    1504         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
     1554        if (!stackFrame.globalData->exception) { // Don't put to an object if toString threw an exception.
    15051555            PutPropertySlot slot;
    15061556            baseValue.put(callFrame, property, value, slot);
    … …  
    15111561}
    15121562
    1513 void JITStubs::cti_op_put_by_val_byte_array(STUB_ARGS)
    1514 {
    1515     BEGIN_STUB_FUNCTION();
    1516    
    1517     CallFrame* callFrame = ARG_callFrame;
    1518     JSGlobalData* globalData = ARG_globalData;
    1519    
    1520     JSValue baseValue = ARG_src1;
    1521     JSValue subscript = ARG_src2;
    1522     JSValue value = ARG_src3;
     1563void JITStubs::cti_op_put_by_val_byte_array(STUB_ARGS_DECLARATION)
     1564{
     1565    BEGIN_STUB_FUNCTION();
     1566    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1567   
     1568    CallFrame* callFrame = stackFrame.callFrame;
     1569    JSGlobalData* globalData = stackFrame.globalData;
     1570   
     1571    JSValue baseValue = stackFrame.args[0].jsValue();
     1572    JSValue subscript = stackFrame.args[1].jsValue();
     1573    JSValue value = stackFrame.args[2].jsValue();
    15231574   
    15241575    if (LIKELY(subscript.isUInt32Fast())) {
    … …  
    15451596    } else {
    15461597        Identifier property(callFrame, subscript.toString(callFrame));
    1547         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
     1598        if (!stackFrame.globalData->exception) { // Don't put to an object if toString threw an exception.
    15481599            PutPropertySlot slot;
    15491600            baseValue.put(callFrame, property, value, slot);
    … …  
    15541605}
    15551606
    1556 EncodedJSValue JITStubs::cti_op_lesseq(STUB_ARGS)
    1557 {
    1558     BEGIN_STUB_FUNCTION();
    1559 
    1560     CallFrame* callFrame = ARG_callFrame;
    1561     JSValue result = jsBoolean(jsLessEq(callFrame, ARG_src1, ARG_src2));
    1562     CHECK_FOR_EXCEPTION_AT_END();
    1563     return JSValue::encode(result);
    1564 }
    1565 
    1566 int JITStubs::cti_op_loop_if_true(STUB_ARGS)
    1567 {
    1568     BEGIN_STUB_FUNCTION();
    1569 
    1570     JSValue src1 = ARG_src1;
    1571 
    1572     CallFrame* callFrame = ARG_callFrame;
     1607EncodedJSValue JITStubs::cti_op_lesseq(STUB_ARGS_DECLARATION)
     1608{
     1609    BEGIN_STUB_FUNCTION();
     1610    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1611
     1612    CallFrame* callFrame = stackFrame.callFrame;
     1613    JSValue result = jsBoolean(jsLessEq(callFrame, stackFrame.args[0].jsValue(), stackFrame.args[1].jsValue()));
     1614    CHECK_FOR_EXCEPTION_AT_END();
     1615    return JSValue::encode(result);
     1616}
     1617
     1618int JITStubs::cti_op_loop_if_true(STUB_ARGS_DECLARATION)
     1619{
     1620    BEGIN_STUB_FUNCTION();
     1621    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1622
     1623    JSValue src1 = stackFrame.args[0].jsValue();
     1624
     1625    CallFrame* callFrame = stackFrame.callFrame;
    15731626
    15741627    bool result = src1.toBoolean(callFrame);
    … …  
    15771630}
    15781631   
    1579 int JITStubs::cti_op_load_varargs(STUB_ARGS)
    1580 {
    1581     BEGIN_STUB_FUNCTION();
    1582     CallFrame* callFrame = ARG_callFrame;
    1583     RegisterFile* registerFile = ARG_registerFile;
    1584     int argsOffset = ARG_int1;
     1632int JITStubs::cti_op_load_varargs(STUB_ARGS_DECLARATION)
     1633{
     1634    BEGIN_STUB_FUNCTION();
     1635    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1636    CallFrame* callFrame = stackFrame.callFrame;
     1637    RegisterFile* registerFile = stackFrame.registerFile;
     1638    int argsOffset = stackFrame.args[0].int32();
    15851639    JSValue arguments = callFrame[argsOffset].jsValue();
    15861640    uint32_t argCount = 0;
    … …  
    15891643            CodeBlock* codeBlock = callFrame->codeBlock();
    15901644            unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1591             ARG_globalData->exception = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPCIndex, codeBlock);
     1645            stackFrame.globalData->exception = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPCIndex, codeBlock);
    15921646            VM_THROW_EXCEPTION();
    15931647        }
    … …  
    15981652            Register* newEnd = callFrame->registers() + sizeDelta;
    15991653            if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
    1600                 ARG_globalData->exception = createStackOverflowError(callFrame);
     1654                stackFrame.globalData->exception = createStackOverflowError(callFrame);
    16011655                VM_THROW_EXCEPTION();
    16021656            }
    … …  
    16081662            Register* newEnd = callFrame->registers() + sizeDelta;
    16091663            if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
    1610                 ARG_globalData->exception = createStackOverflowError(callFrame);
     1664                stackFrame.globalData->exception = createStackOverflowError(callFrame);
    16111665                VM_THROW_EXCEPTION();
    16121666            }
    … …  
    16181672            Register* newEnd = callFrame->registers() + sizeDelta;
    16191673            if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
    1620                 ARG_globalData->exception = createStackOverflowError(callFrame);
     1674                stackFrame.globalData->exception = createStackOverflowError(callFrame);
    16211675                VM_THROW_EXCEPTION();
    16221676            }
    … …  
    16291683            CodeBlock* codeBlock = callFrame->codeBlock();
    16301684            unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1631             ARG_globalData->exception = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPCIndex, codeBlock);
     1685            stackFrame.globalData->exception = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPCIndex, codeBlock);
    16321686            VM_THROW_EXCEPTION();
    16331687        }
    … …  
    16371691}
    16381692
    1639 EncodedJSValue JITStubs::cti_op_negate(STUB_ARGS)
    1640 {
    1641     BEGIN_STUB_FUNCTION();
    1642 
    1643     JSValue src = ARG_src1;
     1693EncodedJSValue JITStubs::cti_op_negate(STUB_ARGS_DECLARATION)
     1694{
     1695    BEGIN_STUB_FUNCTION();
     1696    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1697
     1698    JSValue src = stackFrame.args[0].jsValue();
    16441699
    16451700    double v;
    16461701    if (src.getNumber(v))
    1647         return JSValue::encode(jsNumber(ARG_globalData, -v));
    1648 
    1649     CallFrame* callFrame = ARG_callFrame;
    1650     JSValue result = jsNumber(ARG_globalData, -src.toNumber(callFrame));
    1651     CHECK_FOR_EXCEPTION_AT_END();
    1652     return JSValue::encode(result);
    1653 }
    1654 
    1655 EncodedJSValue JITStubs::cti_op_resolve_base(STUB_ARGS)
    1656 {
    1657     BEGIN_STUB_FUNCTION();
    1658 
    1659     return JSValue::encode(JSC::resolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain()));
    1660 }
    1661 
    1662 EncodedJSValue JITStubs::cti_op_resolve_skip(STUB_ARGS)
    1663 {
    1664     BEGIN_STUB_FUNCTION();
    1665 
    1666     CallFrame* callFrame = ARG_callFrame;
     1702        return JSValue::encode(jsNumber(stackFrame.globalData, -v));
     1703
     1704    CallFrame* callFrame = stackFrame.callFrame;
     1705    JSValue result = jsNumber(stackFrame.globalData, -src.toNumber(callFrame));
     1706    CHECK_FOR_EXCEPTION_AT_END();
     1707    return JSValue::encode(result);
     1708}
     1709
     1710EncodedJSValue JITStubs::cti_op_resolve_base(STUB_ARGS_DECLARATION)
     1711{
     1712    BEGIN_STUB_FUNCTION();
     1713    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1714
     1715    return JSValue::encode(JSC::resolveBase(stackFrame.callFrame, stackFrame.args[0].identifier(), stackFrame.callFrame->scopeChain()));
     1716}
     1717
     1718EncodedJSValue JITStubs::cti_op_resolve_skip(STUB_ARGS_DECLARATION)
     1719{
     1720    BEGIN_STUB_FUNCTION();
     1721    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1722
     1723    CallFrame* callFrame = stackFrame.callFrame;
    16671724    ScopeChainNode* scopeChain = callFrame->scopeChain();
    16681725
    1669     int skip = ARG_int2;
     1726    int skip = stackFrame.args[1].int32();
    16701727
    16711728    ScopeChainIterator iter = scopeChain->begin();
    … …  
    16761733        ASSERT(iter != end);
    16771734    }
    1678     Identifier& ident = *ARG_id1;
     1735    Identifier& ident = stackFrame.args[0].identifier();
    16791736    do {
    16801737        JSObject* o = *iter;
    … …  
    16891746    CodeBlock* codeBlock = callFrame->codeBlock();
    16901747    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1691     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     1748    stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
    16921749    VM_THROW_EXCEPTION();
    16931750}
    16941751
    1695 EncodedJSValue JITStubs::cti_op_resolve_global(STUB_ARGS)
    1696 {
    1697     BEGIN_STUB_FUNCTION();
    1698 
    1699     CallFrame* callFrame = ARG_callFrame;
    1700     JSGlobalObject* globalObject = asGlobalObject(ARG_src1);
    1701     Identifier& ident = *ARG_id2;
    1702     unsigned globalResolveInfoIndex = ARG_int3;
     1752EncodedJSValue JITStubs::cti_op_resolve_global(STUB_ARGS_DECLARATION)
     1753{
     1754    BEGIN_STUB_FUNCTION();
     1755    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1756
     1757    CallFrame* callFrame = stackFrame.callFrame;
     1758    JSGlobalObject* globalObject = asGlobalObject(stackFrame.args[0].jsValue());
     1759    Identifier& ident = stackFrame.args[1].identifier();
     1760    unsigned globalResolveInfoIndex = stackFrame.args[2].int32();
    17031761    ASSERT(globalObject->isGlobalObject());
    17041762
    … …  
    17211779
    17221780    unsigned vPCIndex = callFrame->codeBlock()->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1723     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, callFrame->codeBlock());
     1781    stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, callFrame->codeBlock());
    17241782    VM_THROW_EXCEPTION();
    17251783}
    17261784
    1727 EncodedJSValue JITStubs::cti_op_div(STUB_ARGS)
    1728 {
    1729     BEGIN_STUB_FUNCTION();
    1730 
    1731     JSValue src1 = ARG_src1;
    1732     JSValue src2 = ARG_src2;
     1785EncodedJSValue JITStubs::cti_op_div(STUB_ARGS_DECLARATION)
     1786{
     1787    BEGIN_STUB_FUNCTION();
     1788    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1789
     1790    JSValue src1 = stackFrame.args[0].jsValue();
     1791    JSValue src2 = stackFrame.args[1].jsValue();
    17331792
    17341793    double left;
    17351794    double right;
    17361795    if (src1.getNumber(left) && src2.getNumber(right))
    1737         return JSValue::encode(jsNumber(ARG_globalData, left / right));
    1738 
    1739     CallFrame* callFrame = ARG_callFrame;
    1740     JSValue result = jsNumber(ARG_globalData, src1.toNumber(callFrame) / src2.toNumber(callFrame));
    1741     CHECK_FOR_EXCEPTION_AT_END();
    1742     return JSValue::encode(result);
    1743 }
    1744 
    1745 EncodedJSValue JITStubs::cti_op_pre_dec(STUB_ARGS)
    1746 {
    1747     BEGIN_STUB_FUNCTION();
    1748 
    1749     JSValue v = ARG_src1;
    1750 
    1751     CallFrame* callFrame = ARG_callFrame;
    1752     JSValue result = jsNumber(ARG_globalData, v.toNumber(callFrame) - 1);
    1753     CHECK_FOR_EXCEPTION_AT_END();
    1754     return JSValue::encode(result);
    1755 }
    1756 
    1757 int JITStubs::cti_op_jless(STUB_ARGS)
    1758 {
    1759     BEGIN_STUB_FUNCTION();
    1760 
    1761     JSValue src1 = ARG_src1;
    1762     JSValue src2 = ARG_src2;
    1763     CallFrame* callFrame = ARG_callFrame;
     1796        return JSValue::encode(jsNumber(stackFrame.globalData, left / right));
     1797
     1798    CallFrame* callFrame = stackFrame.callFrame;
     1799    JSValue result = jsNumber(stackFrame.globalData, src1.toNumber(callFrame) / src2.toNumber(callFrame));
     1800    CHECK_FOR_EXCEPTION_AT_END();
     1801    return JSValue::encode(result);
     1802}
     1803
     1804EncodedJSValue JITStubs::cti_op_pre_dec(STUB_ARGS_DECLARATION)
     1805{
     1806    BEGIN_STUB_FUNCTION();
     1807    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1808
     1809    JSValue v = stackFrame.args[0].jsValue();
     1810
     1811    CallFrame* callFrame = stackFrame.callFrame;
     1812    JSValue result = jsNumber(stackFrame.globalData, v.toNumber(callFrame) - 1);
     1813    CHECK_FOR_EXCEPTION_AT_END();
     1814    return JSValue::encode(result);
     1815}
     1816
     1817int JITStubs::cti_op_jless(STUB_ARGS_DECLARATION)
     1818{
     1819    BEGIN_STUB_FUNCTION();
     1820    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1821
     1822    JSValue src1 = stackFrame.args[0].jsValue();
     1823    JSValue src2 = stackFrame.args[1].jsValue();
     1824    CallFrame* callFrame = stackFrame.callFrame;
    17641825
    17651826    bool result = jsLess(callFrame, src1, src2);
    … …  
    17681829}
    17691830
    1770 EncodedJSValue JITStubs::cti_op_not(STUB_ARGS)
    1771 {
    1772     BEGIN_STUB_FUNCTION();
    1773 
    1774     JSValue src = ARG_src1;
    1775 
    1776     CallFrame* callFrame = ARG_callFrame;
     1831EncodedJSValue JITStubs::cti_op_not(STUB_ARGS_DECLARATION)
     1832{
     1833    BEGIN_STUB_FUNCTION();
     1834    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1835
     1836    JSValue src = stackFrame.args[0].jsValue();
     1837
     1838    CallFrame* callFrame = stackFrame.callFrame;
    17771839
    17781840    JSValue result = jsBoolean(!src.toBoolean(callFrame));
    … …  
    17811843}
    17821844
    1783 int JITStubs::cti_op_jtrue(STUB_ARGS)
    1784 {
    1785     BEGIN_STUB_FUNCTION();
    1786 
    1787     JSValue src1 = ARG_src1;
    1788 
    1789     CallFrame* callFrame = ARG_callFrame;
     1845int JITStubs::cti_op_jtrue(STUB_ARGS_DECLARATION)
     1846{
     1847    BEGIN_STUB_FUNCTION();
     1848    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1849
     1850    JSValue src1 = stackFrame.args[0].jsValue();
     1851
     1852    CallFrame* callFrame = stackFrame.callFrame;
    17901853
    17911854    bool result = src1.toBoolean(callFrame);
    … …  
    17941857}
    17951858
    1796 VoidPtrPair JITStubs::cti_op_post_inc(STUB_ARGS)
    1797 {
    1798     BEGIN_STUB_FUNCTION();
    1799 
    1800     JSValue v = ARG_src1;
    1801 
    1802     CallFrame* callFrame = ARG_callFrame;
     1859VoidPtrPair JITStubs::cti_op_post_inc(STUB_ARGS_DECLARATION)
     1860{
     1861    BEGIN_STUB_FUNCTION();
     1862    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1863
     1864    JSValue v = stackFrame.args[0].jsValue();
     1865
     1866    CallFrame* callFrame = stackFrame.callFrame;
    18031867
    18041868    JSValue number = v.toJSNumber(callFrame);
    18051869    CHECK_FOR_EXCEPTION_AT_END();
    18061870
    1807     RETURN_PAIR(JSValue::encode(number), JSValue::encode(jsNumber(ARG_globalData, number.uncheckedGetNumber() + 1)));
    1808 }
    1809 
    1810 EncodedJSValue JITStubs::cti_op_eq(STUB_ARGS)
    1811 {
    1812     BEGIN_STUB_FUNCTION();
    1813 
    1814     JSValue src1 = ARG_src1;
    1815     JSValue src2 = ARG_src2;
    1816 
    1817     CallFrame* callFrame = ARG_callFrame;
     1871    RETURN_PAIR(JSValue::encode(number), JSValue::encode(jsNumber(stackFrame.globalData, number.uncheckedGetNumber() + 1)));
     1872}
     1873
     1874EncodedJSValue JITStubs::cti_op_eq(STUB_ARGS_DECLARATION)
     1875{
     1876    BEGIN_STUB_FUNCTION();
     1877    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1878
     1879    JSValue src1 = stackFrame.args[0].jsValue();
     1880    JSValue src2 = stackFrame.args[1].jsValue();
     1881
     1882    CallFrame* callFrame = stackFrame.callFrame;
    18181883
    18191884    ASSERT(!JSValue::areBothInt32Fast(src1, src2));
    … …  
    18231888}
    18241889
    1825 EncodedJSValue JITStubs::cti_op_lshift(STUB_ARGS)
    1826 {
    1827     BEGIN_STUB_FUNCTION();
    1828 
    1829     JSValue val = ARG_src1;
    1830     JSValue shift = ARG_src2;
     1890EncodedJSValue JITStubs::cti_op_lshift(STUB_ARGS_DECLARATION)
     1891{
     1892    BEGIN_STUB_FUNCTION();
     1893    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1894
     1895    JSValue val = stackFrame.args[0].jsValue();
     1896    JSValue shift = stackFrame.args[1].jsValue();
    18311897
    18321898    int32_t left;
    18331899    uint32_t right;
    18341900    if (JSValue::areBothInt32Fast(val, shift))
    1835         return JSValue::encode(jsNumber(ARG_globalData, val.getInt32Fast() << (shift.getInt32Fast() & 0x1f)));
     1901        return JSValue::encode(jsNumber(stackFrame.globalData, val.getInt32Fast() << (shift.getInt32Fast() & 0x1f)));
    18361902    if (val.numberToInt32(left) && shift.numberToUInt32(right))
    1837         return JSValue::encode(jsNumber(ARG_globalData, left << (right & 0x1f)));
    1838 
    1839     CallFrame* callFrame = ARG_callFrame;
    1840     JSValue result = jsNumber(ARG_globalData, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f));
    1841     CHECK_FOR_EXCEPTION_AT_END();
    1842     return JSValue::encode(result);
    1843 }
    1844 
    1845 EncodedJSValue JITStubs::cti_op_bitand(STUB_ARGS)
    1846 {
    1847     BEGIN_STUB_FUNCTION();
    1848 
    1849     JSValue src1 = ARG_src1;
    1850     JSValue src2 = ARG_src2;
     1903        return JSValue::encode(jsNumber(stackFrame.globalData, left << (right & 0x1f)));
     1904
     1905    CallFrame* callFrame = stackFrame.callFrame;
     1906    JSValue result = jsNumber(stackFrame.globalData, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f));
     1907    CHECK_FOR_EXCEPTION_AT_END();
     1908    return JSValue::encode(result);
     1909}
     1910
     1911EncodedJSValue JITStubs::cti_op_bitand(STUB_ARGS_DECLARATION)
     1912{
     1913    BEGIN_STUB_FUNCTION();
     1914    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1915
     1916    JSValue src1 = stackFrame.args[0].jsValue();
     1917    JSValue src2 = stackFrame.args[1].jsValue();
    18511918
    18521919    int32_t left;
    18531920    int32_t right;
    18541921    if (src1.numberToInt32(left) && src2.numberToInt32(right))
    1855         return JSValue::encode(jsNumber(ARG_globalData, left & right));
    1856 
    1857     CallFrame* callFrame = ARG_callFrame;
    1858     JSValue result = jsNumber(ARG_globalData, src1.toInt32(callFrame) & src2.toInt32(callFrame));
    1859     CHECK_FOR_EXCEPTION_AT_END();
    1860     return JSValue::encode(result);
    1861 }
    1862 
    1863 EncodedJSValue JITStubs::cti_op_rshift(STUB_ARGS)
    1864 {
    1865     BEGIN_STUB_FUNCTION();
    1866 
    1867     JSValue val = ARG_src1;
    1868     JSValue shift = ARG_src2;
     1922        return JSValue::encode(jsNumber(stackFrame.globalData, left & right));
     1923
     1924    CallFrame* callFrame = stackFrame.callFrame;
     1925    JSValue result = jsNumber(stackFrame.globalData, src1.toInt32(callFrame) & src2.toInt32(callFrame));
     1926    CHECK_FOR_EXCEPTION_AT_END();
     1927    return JSValue::encode(result);
     1928}
     1929
     1930EncodedJSValue JITStubs::cti_op_rshift(STUB_ARGS_DECLARATION)
     1931{
     1932    BEGIN_STUB_FUNCTION();
     1933    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1934
     1935    JSValue val = stackFrame.args[0].jsValue();
     1936    JSValue shift = stackFrame.args[1].jsValue();
    18691937
    18701938    int32_t left;
    … …  
    18731941        return JSValue::encode(JSFastMath::rightShiftImmediateNumbers(val, shift));
    18741942    if (val.numberToInt32(left) && shift.numberToUInt32(right))
    1875         return JSValue::encode(jsNumber(ARG_globalData, left >> (right & 0x1f)));
    1876 
    1877     CallFrame* callFrame = ARG_callFrame;
    1878     JSValue result = jsNumber(ARG_globalData, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
    1879     CHECK_FOR_EXCEPTION_AT_END();
    1880     return JSValue::encode(result);
    1881 }
    1882 
    1883 EncodedJSValue JITStubs::cti_op_bitnot(STUB_ARGS)
    1884 {
    1885     BEGIN_STUB_FUNCTION();
    1886 
    1887     JSValue src = ARG_src1;
     1943        return JSValue::encode(jsNumber(stackFrame.globalData, left >> (right & 0x1f)));
     1944
     1945    CallFrame* callFrame = stackFrame.callFrame;
     1946    JSValue result = jsNumber(stackFrame.globalData, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
     1947    CHECK_FOR_EXCEPTION_AT_END();
     1948    return JSValue::encode(result);
     1949}
     1950
     1951EncodedJSValue JITStubs::cti_op_bitnot(STUB_ARGS_DECLARATION)
     1952{
     1953    BEGIN_STUB_FUNCTION();
     1954    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1955
     1956    JSValue src = stackFrame.args[0].jsValue();
    18881957
    18891958    int value;
    18901959    if (src.numberToInt32(value))
    1891         return JSValue::encode(jsNumber(ARG_globalData, ~value));
    1892 
    1893     CallFrame* callFrame = ARG_callFrame;
    1894     JSValue result = jsNumber(ARG_globalData, ~src.toInt32(callFrame));
    1895     CHECK_FOR_EXCEPTION_AT_END();
    1896     return JSValue::encode(result);
    1897 }
    1898 
    1899 VoidPtrPair JITStubs::cti_op_resolve_with_base(STUB_ARGS)
    1900 {
    1901     BEGIN_STUB_FUNCTION();
    1902 
    1903     CallFrame* callFrame = ARG_callFrame;
     1960        return JSValue::encode(jsNumber(stackFrame.globalData, ~value));
     1961
     1962    CallFrame* callFrame = stackFrame.callFrame;
     1963    JSValue result = jsNumber(stackFrame.globalData, ~src.toInt32(callFrame));
     1964    CHECK_FOR_EXCEPTION_AT_END();
     1965    return JSValue::encode(result);
     1966}
     1967
     1968VoidPtrPair JITStubs::cti_op_resolve_with_base(STUB_ARGS_DECLARATION)
     1969{
     1970    BEGIN_STUB_FUNCTION();
     1971    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     1972
     1973    CallFrame* callFrame = stackFrame.callFrame;
    19041974    ScopeChainNode* scopeChain = callFrame->scopeChain();
    19051975
    … …  
    19111981    ASSERT(iter != end);
    19121982
    1913     Identifier& ident = *ARG_id1;
     1983    Identifier& ident = stackFrame.args[0].identifier();
    19141984    JSObject* base;
    19151985    do {
    … …  
    19271997    CodeBlock* codeBlock = callFrame->codeBlock();
    19281998    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    1929     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     1999    stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
    19302000    VM_THROW_EXCEPTION_2();
    19312001}
    19322002
    1933 JSObject* JITStubs::cti_op_new_func_exp(STUB_ARGS)
    1934 {
    1935     BEGIN_STUB_FUNCTION();
    1936 
    1937     return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
    1938 }
    1939 
    1940 EncodedJSValue JITStubs::cti_op_mod(STUB_ARGS)
    1941 {
    1942     BEGIN_STUB_FUNCTION();
    1943 
    1944     JSValue dividendValue = ARG_src1;
    1945     JSValue divisorValue = ARG_src2;
    1946 
    1947     CallFrame* callFrame = ARG_callFrame;
     2003JSObject* JITStubs::cti_op_new_func_exp(STUB_ARGS_DECLARATION)
     2004{
     2005    BEGIN_STUB_FUNCTION();
     2006    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2007
     2008    return stackFrame.args[0].funcExprNode()->makeFunction(stackFrame.callFrame, stackFrame.callFrame->scopeChain());
     2009}
     2010
     2011EncodedJSValue JITStubs::cti_op_mod(STUB_ARGS_DECLARATION)
     2012{
     2013    BEGIN_STUB_FUNCTION();
     2014    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2015
     2016    JSValue dividendValue = stackFrame.args[0].jsValue();
     2017    JSValue divisorValue = stackFrame.args[1].jsValue();
     2018
     2019    CallFrame* callFrame = stackFrame.callFrame;
    19482020    double d = dividendValue.toNumber(callFrame);
    1949     JSValue result = jsNumber(ARG_globalData, fmod(d, divisorValue.toNumber(callFrame)));
    1950     CHECK_FOR_EXCEPTION_AT_END();
    1951     return JSValue::encode(result);
    1952 }
    1953 
    1954 EncodedJSValue JITStubs::cti_op_less(STUB_ARGS)
    1955 {
    1956     BEGIN_STUB_FUNCTION();
    1957 
    1958     CallFrame* callFrame = ARG_callFrame;
    1959     JSValue result = jsBoolean(jsLess(callFrame, ARG_src1, ARG_src2));
    1960     CHECK_FOR_EXCEPTION_AT_END();
    1961     return JSValue::encode(result);
    1962 }
    1963 
    1964 EncodedJSValue JITStubs::cti_op_neq(STUB_ARGS)
    1965 {
    1966     BEGIN_STUB_FUNCTION();
    1967 
    1968     JSValue src1 = ARG_src1;
    1969     JSValue src2 = ARG_src2;
     2021    JSValue result = jsNumber(stackFrame.globalData, fmod(d, divisorValue.toNumber(callFrame)));
     2022    CHECK_FOR_EXCEPTION_AT_END();
     2023    return JSValue::encode(result);
     2024}
     2025
     2026EncodedJSValue JITStubs::cti_op_less(STUB_ARGS_DECLARATION)
     2027{
     2028    BEGIN_STUB_FUNCTION();
     2029    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2030
     2031    CallFrame* callFrame = stackFrame.callFrame;
     2032    JSValue result = jsBoolean(jsLess(callFrame, stackFrame.args[0].jsValue(), stackFrame.args[1].jsValue()));
     2033    CHECK_FOR_EXCEPTION_AT_END();
     2034    return JSValue::encode(result);
     2035}
     2036
     2037EncodedJSValue JITStubs::cti_op_neq(STUB_ARGS_DECLARATION)
     2038{
     2039    BEGIN_STUB_FUNCTION();
     2040    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2041
     2042    JSValue src1 = stackFrame.args[0].jsValue();
     2043    JSValue src2 = stackFrame.args[1].jsValue();
    19702044
    19712045    ASSERT(!JSValue::areBothInt32Fast(src1, src2));
    19722046
    1973     CallFrame* callFrame = ARG_callFrame;
     2047    CallFrame* callFrame = stackFrame.callFrame;
    19742048    JSValue result = jsBoolean(!JSValue::equalSlowCaseInline(callFrame, src1, src2));
    19752049    CHECK_FOR_EXCEPTION_AT_END();
    … …  
    19772051}
    19782052
    1979 VoidPtrPair JITStubs::cti_op_post_dec(STUB_ARGS)
    1980 {
    1981     BEGIN_STUB_FUNCTION();
    1982 
    1983     JSValue v = ARG_src1;
    1984 
    1985     CallFrame* callFrame = ARG_callFrame;
     2053VoidPtrPair JITStubs::cti_op_post_dec(STUB_ARGS_DECLARATION)
     2054{
     2055    BEGIN_STUB_FUNCTION();
     2056    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2057
     2058    JSValue v = stackFrame.args[0].jsValue();
     2059
     2060    CallFrame* callFrame = stackFrame.callFrame;
    19862061
    19872062    JSValue number = v.toJSNumber(callFrame);
    19882063    CHECK_FOR_EXCEPTION_AT_END();
    19892064
    1990     RETURN_PAIR(JSValue::encode(number), JSValue::encode(jsNumber(ARG_globalData, number.uncheckedGetNumber() - 1)));
    1991 }
    1992 
    1993 EncodedJSValue JITStubs::cti_op_urshift(STUB_ARGS)
    1994 {
    1995     BEGIN_STUB_FUNCTION();
    1996 
    1997     JSValue val = ARG_src1;
    1998     JSValue shift = ARG_src2;
    1999 
    2000     CallFrame* callFrame = ARG_callFrame;
     2065    RETURN_PAIR(JSValue::encode(number), JSValue::encode(jsNumber(stackFrame.globalData, number.uncheckedGetNumber() - 1)));
     2066}
     2067
     2068EncodedJSValue JITStubs::cti_op_urshift(STUB_ARGS_DECLARATION)
     2069{
     2070    BEGIN_STUB_FUNCTION();
     2071    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2072
     2073    JSValue val = stackFrame.args[0].jsValue();
     2074    JSValue shift = stackFrame.args[1].jsValue();
     2075
     2076    CallFrame* callFrame = stackFrame.callFrame;
    20012077
    20022078    if (JSFastMath::canDoFastUrshift(val, shift))
    20032079        return JSValue::encode(JSFastMath::rightShiftImmediateNumbers(val, shift));
    20042080    else {
    2005         JSValue result = jsNumber(ARG_globalData, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
     2081        JSValue result = jsNumber(stackFrame.globalData, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
    20062082        CHECK_FOR_EXCEPTION_AT_END();
    20072083        return JSValue::encode(result);
    … …  
    20092085}
    20102086
    2011 EncodedJSValue JITStubs::cti_op_bitxor(STUB_ARGS)
    2012 {
    2013     BEGIN_STUB_FUNCTION();
    2014 
    2015     JSValue src1 = ARG_src1;
    2016     JSValue src2 = ARG_src2;
    2017 
    2018     CallFrame* callFrame = ARG_callFrame;
    2019 
    2020     JSValue result = jsNumber(ARG_globalData, src1.toInt32(callFrame) ^ src2.toInt32(callFrame));
    2021     CHECK_FOR_EXCEPTION_AT_END();
    2022     return JSValue::encode(result);
    2023 }
    2024 
    2025 JSObject* JITStubs::cti_op_new_regexp(STUB_ARGS)
    2026 {
    2027     BEGIN_STUB_FUNCTION();
    2028 
    2029     return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1);
    2030 }
    2031 
    2032 EncodedJSValue JITStubs::cti_op_bitor(STUB_ARGS)
    2033 {
    2034     BEGIN_STUB_FUNCTION();
    2035 
    2036     JSValue src1 = ARG_src1;
    2037     JSValue src2 = ARG_src2;
    2038 
    2039     CallFrame* callFrame = ARG_callFrame;
    2040 
    2041     JSValue result = jsNumber(ARG_globalData, src1.toInt32(callFrame) | src2.toInt32(callFrame));
    2042     CHECK_FOR_EXCEPTION_AT_END();
    2043     return JSValue::encode(result);
    2044 }
    2045 
    2046 EncodedJSValue JITStubs::cti_op_call_eval(STUB_ARGS)
    2047 {
    2048     BEGIN_STUB_FUNCTION();
    2049 
    2050     CallFrame* callFrame = ARG_callFrame;
    2051     RegisterFile* registerFile = ARG_registerFile;
    2052 
    2053     Interpreter* interpreter = ARG_globalData->interpreter;
    2054    
    2055     JSValue funcVal = ARG_src1;
    2056     int registerOffset = ARG_int2;
    2057     int argCount = ARG_int3;
     2087EncodedJSValue JITStubs::cti_op_bitxor(STUB_ARGS_DECLARATION)
     2088{
     2089    BEGIN_STUB_FUNCTION();
     2090    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2091
     2092    JSValue src1 = stackFrame.args[0].jsValue();
     2093    JSValue src2 = stackFrame.args[1].jsValue();
     2094
     2095    CallFrame* callFrame = stackFrame.callFrame;
     2096
     2097    JSValue result = jsNumber(stackFrame.globalData, src1.toInt32(callFrame) ^ src2.toInt32(callFrame));
     2098    CHECK_FOR_EXCEPTION_AT_END();
     2099    return JSValue::encode(result);
     2100}
     2101
     2102JSObject* JITStubs::cti_op_new_regexp(STUB_ARGS_DECLARATION)
     2103{
     2104    BEGIN_STUB_FUNCTION();
     2105    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2106
     2107    return new (stackFrame.globalData) RegExpObject(stackFrame.callFrame->lexicalGlobalObject()->regExpStructure(), stackFrame.args[0].regExp());
     2108}
     2109
     2110EncodedJSValue JITStubs::cti_op_bitor(STUB_ARGS_DECLARATION)
     2111{
     2112    BEGIN_STUB_FUNCTION();
     2113    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2114
     2115    JSValue src1 = stackFrame.args[0].jsValue();
     2116    JSValue src2 = stackFrame.args[1].jsValue();
     2117
     2118    CallFrame* callFrame = stackFrame.callFrame;
     2119
     2120    JSValue result = jsNumber(stackFrame.globalData, src1.toInt32(callFrame) | src2.toInt32(callFrame));
     2121    CHECK_FOR_EXCEPTION_AT_END();
     2122    return JSValue::encode(result);
     2123}
     2124
     2125EncodedJSValue JITStubs::cti_op_call_eval(STUB_ARGS_DECLARATION)
     2126{
     2127    BEGIN_STUB_FUNCTION();
     2128    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2129
     2130    CallFrame* callFrame = stackFrame.callFrame;
     2131    RegisterFile* registerFile = stackFrame.registerFile;
     2132
     2133    Interpreter* interpreter = stackFrame.globalData->interpreter;
     2134   
     2135    JSValue funcVal = stackFrame.args[0].jsValue();
     2136    int registerOffset = stackFrame.args[1].int32();
     2137    int argCount = stackFrame.args[2].int32();
    20582138
    20592139    Register* newCallFrame = callFrame->registers() + registerOffset;
    … …  
    20662146        JSValue result = interpreter->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
    20672147        if (UNLIKELY(exceptionValue != JSValue())) {
    2068             ARG_globalData->exception = exceptionValue;
     2148            stackFrame.globalData->exception = exceptionValue;
    20692149            VM_THROW_EXCEPTION_AT_END();
    20702150        }
    … …  
    20752155}
    20762156
    2077 EncodedJSValue JITStubs::cti_op_throw(STUB_ARGS)
    2078 {
    2079     BEGIN_STUB_FUNCTION();
    2080 
    2081     CallFrame* callFrame = ARG_callFrame;
     2157EncodedJSValue JITStubs::cti_op_throw(STUB_ARGS_DECLARATION)
     2158{
     2159    BEGIN_STUB_FUNCTION();
     2160    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2161
     2162    CallFrame* callFrame = stackFrame.callFrame;
    20822163    CodeBlock* codeBlock = callFrame->codeBlock();
    20832164
    20842165    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    20852166
    2086     JSValue exceptionValue = ARG_src1;
     2167    JSValue exceptionValue = stackFrame.args[0].jsValue();
    20872168    ASSERT(exceptionValue);
    20882169
    2089     HandlerInfo* handler = ARG_globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, true);
     2170    HandlerInfo* handler = stackFrame.globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, true);
    20902171
    20912172    if (!handler) {
    2092         *ARG_exception = exceptionValue;
     2173        *stackFrame.exception = exceptionValue;
    20932174        return JSValue::encode(jsNull());
    20942175    }
    20952176
    2096     ARG_setCallFrame(callFrame);
     2177    stackFrame.callFrame = callFrame;
    20972178    void* catchRoutine = handler->nativeCode.addressForExceptionHandler();
    20982179    ASSERT(catchRoutine);
    … …  
    21012182}
    21022183
    2103 JSPropertyNameIterator* JITStubs::cti_op_get_pnames(STUB_ARGS)
    2104 {
    2105     BEGIN_STUB_FUNCTION();
    2106 
    2107     return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1);
    2108 }
    2109 
    2110 EncodedJSValue JITStubs::cti_op_next_pname(STUB_ARGS)
    2111 {
    2112     BEGIN_STUB_FUNCTION();
    2113 
    2114     JSPropertyNameIterator* it = ARG_pni1;
    2115     JSValue temp = it->next(ARG_callFrame);
     2184JSPropertyNameIterator* JITStubs::cti_op_get_pnames(STUB_ARGS_DECLARATION)
     2185{
     2186    BEGIN_STUB_FUNCTION();
     2187    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2188
     2189    return JSPropertyNameIterator::create(stackFrame.callFrame, stackFrame.args[0].jsValue());
     2190}
     2191
     2192EncodedJSValue JITStubs::cti_op_next_pname(STUB_ARGS_DECLARATION)
     2193{
     2194    BEGIN_STUB_FUNCTION();
     2195    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2196
     2197    JSPropertyNameIterator* it = stackFrame.args[0].propertyNameIterator();
     2198    JSValue temp = it->next(stackFrame.callFrame);
    21162199    if (!temp)
    21172200        it->invalidate();
    … …  
    21192202}
    21202203
    2121 JSObject* JITStubs::cti_op_push_scope(STUB_ARGS)
    2122 {
    2123     BEGIN_STUB_FUNCTION();
    2124 
    2125     JSObject* o = ARG_src1.toObject(ARG_callFrame);
     2204JSObject* JITStubs::cti_op_push_scope(STUB_ARGS_DECLARATION)
     2205{
     2206    BEGIN_STUB_FUNCTION();
     2207    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2208
     2209    JSObject* o = stackFrame.args[0].jsValue().toObject(stackFrame.callFrame);
    21262210    CHECK_FOR_EXCEPTION();
    2127     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->push(o));
     2211    stackFrame.callFrame->setScopeChain(stackFrame.callFrame->scopeChain()->push(o));
    21282212    return o;
    21292213}
    21302214
    2131 void JITStubs::cti_op_pop_scope(STUB_ARGS)
    2132 {
    2133     BEGIN_STUB_FUNCTION();
    2134 
    2135     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->pop());
    2136 }
    2137 
    2138 EncodedJSValue JITStubs::cti_op_typeof(STUB_ARGS)
    2139 {
    2140     BEGIN_STUB_FUNCTION();
    2141 
    2142     return JSValue::encode(jsTypeStringForValue(ARG_callFrame, ARG_src1));
    2143 }
    2144 
    2145 EncodedJSValue JITStubs::cti_op_is_undefined(STUB_ARGS)
    2146 {
    2147     BEGIN_STUB_FUNCTION();
    2148 
    2149     JSValue v = ARG_src1;
     2215void JITStubs::cti_op_pop_scope(STUB_ARGS_DECLARATION)
     2216{
     2217    BEGIN_STUB_FUNCTION();
     2218    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2219
     2220    stackFrame.callFrame->setScopeChain(stackFrame.callFrame->scopeChain()->pop());
     2221}
     2222
     2223EncodedJSValue JITStubs::cti_op_typeof(STUB_ARGS_DECLARATION)
     2224{
     2225    BEGIN_STUB_FUNCTION();
     2226    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2227
     2228    return JSValue::encode(jsTypeStringForValue(stackFrame.callFrame, stackFrame.args[0].jsValue()));
     2229}
     2230
     2231EncodedJSValue JITStubs::cti_op_is_undefined(STUB_ARGS_DECLARATION)
     2232{
     2233    BEGIN_STUB_FUNCTION();
     2234    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2235
     2236    JSValue v = stackFrame.args[0].jsValue();
    21502237    return JSValue::encode(jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined()));
    21512238}
    21522239
    2153 EncodedJSValue JITStubs::cti_op_is_boolean(STUB_ARGS)
    2154 {
    2155     BEGIN_STUB_FUNCTION();
    2156 
    2157     return JSValue::encode(jsBoolean(ARG_src1.isBoolean()));
    2158 }
    2159 
    2160 EncodedJSValue JITStubs::cti_op_is_number(STUB_ARGS)
    2161 {
    2162     BEGIN_STUB_FUNCTION();
    2163 
    2164     return JSValue::encode(jsBoolean(ARG_src1.isNumber()));
    2165 }
    2166 
    2167 EncodedJSValue JITStubs::cti_op_is_string(STUB_ARGS)
    2168 {
    2169     BEGIN_STUB_FUNCTION();
    2170 
    2171     return JSValue::encode(jsBoolean(isJSString(ARG_globalData, ARG_src1)));
    2172 }
    2173 
    2174 EncodedJSValue JITStubs::cti_op_is_object(STUB_ARGS)
    2175 {
    2176     BEGIN_STUB_FUNCTION();
    2177 
    2178     return JSValue::encode(jsBoolean(jsIsObjectType(ARG_src1)));
    2179 }
    2180 
    2181 EncodedJSValue JITStubs::cti_op_is_function(STUB_ARGS)
    2182 {
    2183     BEGIN_STUB_FUNCTION();
    2184 
    2185     return JSValue::encode(jsBoolean(jsIsFunctionType(ARG_src1)));
    2186 }
    2187 
    2188 EncodedJSValue JITStubs::cti_op_stricteq(STUB_ARGS)
    2189 {
    2190     BEGIN_STUB_FUNCTION();
    2191 
    2192     JSValue src1 = ARG_src1;
    2193     JSValue src2 = ARG_src2;
     2240EncodedJSValue JITStubs::cti_op_is_boolean(STUB_ARGS_DECLARATION)
     2241{
     2242    BEGIN_STUB_FUNCTION();
     2243    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2244
     2245    return JSValue::encode(jsBoolean(stackFrame.args[0].jsValue().isBoolean()));
     2246}
     2247
     2248EncodedJSValue JITStubs::cti_op_is_number(STUB_ARGS_DECLARATION)
     2249{
     2250    BEGIN_STUB_FUNCTION();
     2251    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2252
     2253    return JSValue::encode(jsBoolean(stackFrame.args[0].jsValue().isNumber()));
     2254}
     2255
     2256EncodedJSValue JITStubs::cti_op_is_string(STUB_ARGS_DECLARATION)
     2257{
     2258    BEGIN_STUB_FUNCTION();
     2259    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2260
     2261    return JSValue::encode(jsBoolean(isJSString(stackFrame.globalData, stackFrame.args[0].jsValue())));
     2262}
     2263
     2264EncodedJSValue JITStubs::cti_op_is_object(STUB_ARGS_DECLARATION)
     2265{
     2266    BEGIN_STUB_FUNCTION();
     2267    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2268
     2269    return JSValue::encode(jsBoolean(jsIsObjectType(stackFrame.args[0].jsValue())));
     2270}
     2271
     2272EncodedJSValue JITStubs::cti_op_is_function(STUB_ARGS_DECLARATION)
     2273{
     2274    BEGIN_STUB_FUNCTION();
     2275    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2276
     2277    return JSValue::encode(jsBoolean(jsIsFunctionType(stackFrame.args[0].jsValue())));
     2278}
     2279
     2280EncodedJSValue JITStubs::cti_op_stricteq(STUB_ARGS_DECLARATION)
     2281{
     2282    BEGIN_STUB_FUNCTION();
     2283    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2284
     2285    JSValue src1 = stackFrame.args[0].jsValue();
     2286    JSValue src2 = stackFrame.args[1].jsValue();
    21942287
    21952288    return JSValue::encode(jsBoolean(JSValue::strictEqual(src1, src2)));
    21962289}
    21972290
    2198 EncodedJSValue JITStubs::cti_op_to_primitive(STUB_ARGS)
    2199 {
    2200     BEGIN_STUB_FUNCTION();
    2201 
    2202     return JSValue::encode(ARG_src1.toPrimitive(ARG_callFrame));
    2203 }
    2204 
    2205 EncodedJSValue JITStubs::cti_op_strcat(STUB_ARGS)
    2206 {
    2207     BEGIN_STUB_FUNCTION();
    2208 
    2209     return JSValue::encode(concatenateStrings(ARG_callFrame, &ARG_callFrame->registers()[ARG_int1], ARG_int2));
    2210 }
    2211 
    2212 EncodedJSValue JITStubs::cti_op_nstricteq(STUB_ARGS)
    2213 {
    2214     BEGIN_STUB_FUNCTION();
    2215 
    2216     JSValue src1 = ARG_src1;
    2217     JSValue src2 = ARG_src2;
     2291EncodedJSValue JITStubs::cti_op_to_primitive(STUB_ARGS_DECLARATION)
     2292{
     2293    BEGIN_STUB_FUNCTION();
     2294    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2295
     2296    return JSValue::encode(stackFrame.args[0].jsValue().toPrimitive(stackFrame.callFrame));
     2297}
     2298
     2299EncodedJSValue JITStubs::cti_op_strcat(STUB_ARGS_DECLARATION)
     2300{
     2301    BEGIN_STUB_FUNCTION();
     2302    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2303
     2304    return JSValue::encode(concatenateStrings(stackFrame.callFrame, &stackFrame.callFrame->registers()[stackFrame.args[0].int32()], stackFrame.args[1].int32()));
     2305}
     2306
     2307EncodedJSValue JITStubs::cti_op_nstricteq(STUB_ARGS_DECLARATION)
     2308{
     2309    BEGIN_STUB_FUNCTION();
     2310    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2311
     2312    JSValue src1 = stackFrame.args[0].jsValue();
     2313    JSValue src2 = stackFrame.args[1].jsValue();
    22182314
    22192315    return JSValue::encode(jsBoolean(!JSValue::strictEqual(src1, src2)));
    22202316}
    22212317
    2222 EncodedJSValue JITStubs::cti_op_to_jsnumber(STUB_ARGS)
    2223 {
    2224     BEGIN_STUB_FUNCTION();
    2225 
    2226     JSValue src = ARG_src1;
    2227     CallFrame* callFrame = ARG_callFrame;
     2318EncodedJSValue JITStubs::cti_op_to_jsnumber(STUB_ARGS_DECLARATION)
     2319{
     2320    BEGIN_STUB_FUNCTION();
     2321    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2322
     2323    JSValue src = stackFrame.args[0].jsValue();
     2324    CallFrame* callFrame = stackFrame.callFrame;
    22282325
    22292326    JSValue result = src.toJSNumber(callFrame);
    … …  
    22322329}
    22332330
    2234 EncodedJSValue JITStubs::cti_op_in(STUB_ARGS)
    2235 {
    2236     BEGIN_STUB_FUNCTION();
    2237 
    2238     CallFrame* callFrame = ARG_callFrame;
    2239     JSValue baseVal = ARG_src2;
     2331EncodedJSValue JITStubs::cti_op_in(STUB_ARGS_DECLARATION)
     2332{
     2333    BEGIN_STUB_FUNCTION();
     2334    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2335
     2336    CallFrame* callFrame = stackFrame.callFrame;
     2337    JSValue baseVal = stackFrame.args[1].jsValue();
    22402338
    22412339    if (!baseVal.isObject()) {
    2242         CallFrame* callFrame = ARG_callFrame;
     2340        CallFrame* callFrame = stackFrame.callFrame;
    22432341        CodeBlock* codeBlock = callFrame->codeBlock();
    22442342        unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
    2245         ARG_globalData->exception = createInvalidParamError(callFrame, "in", baseVal, vPCIndex, codeBlock);
     2343        stackFrame.globalData->exception = createInvalidParamError(callFrame, "in", baseVal, vPCIndex, codeBlock);
    22462344        VM_THROW_EXCEPTION();
    22472345    }
    22482346
    2249     JSValue propName = ARG_src1;
     2347    JSValue propName = stackFrame.args[0].jsValue();
    22502348    JSObject* baseObj = asObject(baseVal);
    22512349
    … …  
    22592357}
    22602358
    2261 JSObject* JITStubs::cti_op_push_new_scope(STUB_ARGS)
    2262 {
    2263     BEGIN_STUB_FUNCTION();
    2264 
    2265     JSObject* scope = new (ARG_globalData) JSStaticScopeObject(ARG_callFrame, *ARG_id1, ARG_src2, DontDelete);
    2266 
    2267     CallFrame* callFrame = ARG_callFrame;
     2359JSObject* JITStubs::cti_op_push_new_scope(STUB_ARGS_DECLARATION)
     2360{
     2361    BEGIN_STUB_FUNCTION();
     2362    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2363
     2364    JSObject* scope = new (stackFrame.globalData) JSStaticScopeObject(stackFrame.callFrame, stackFrame.args[0].identifier(), stackFrame.args[1].jsValue(), DontDelete);
     2365
     2366    CallFrame* callFrame = stackFrame.callFrame;
    22682367    callFrame->setScopeChain(callFrame->scopeChain()->push(scope));
    22692368    return scope;
    22702369}
    22712370
    2272 void JITStubs::cti_op_jmp_scopes(STUB_ARGS)
    2273 {
    2274     BEGIN_STUB_FUNCTION();
    2275 
    2276     unsigned count = ARG_int1;
    2277     CallFrame* callFrame = ARG_callFrame;
     2371void JITStubs::cti_op_jmp_scopes(STUB_ARGS_DECLARATION)
     2372{
     2373    BEGIN_STUB_FUNCTION();
     2374    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2375
     2376    unsigned count = stackFrame.args[0].int32();
     2377    CallFrame* callFrame = stackFrame.callFrame;
    22782378
    22792379    ScopeChainNode* tmp = callFrame->scopeChain();
    … …  
    22832383}
    22842384
    2285 void JITStubs::cti_op_put_by_index(STUB_ARGS)
    2286 {
    2287     BEGIN_STUB_FUNCTION();
    2288 
    2289     CallFrame* callFrame = ARG_callFrame;
    2290     unsigned property = ARG_int2;
    2291 
    2292     ARG_src1.put(callFrame, property, ARG_src3);
    2293 }
    2294 
    2295 void* JITStubs::cti_op_switch_imm(STUB_ARGS)
    2296 {
    2297     BEGIN_STUB_FUNCTION();
    2298 
    2299     JSValue scrutinee = ARG_src1;
    2300     unsigned tableIndex = ARG_int2;
    2301     CallFrame* callFrame = ARG_callFrame;
     2385void JITStubs::cti_op_put_by_index(STUB_ARGS_DECLARATION)
     2386{
     2387    BEGIN_STUB_FUNCTION();
     2388    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2389
     2390    CallFrame* callFrame = stackFrame.callFrame;
     2391    unsigned property = stackFrame.args[1].int32();
     2392
     2393    stackFrame.args[0].jsValue().put(callFrame, property, stackFrame.args[2].jsValue());
     2394}
     2395
     2396void* JITStubs::cti_op_switch_imm(STUB_ARGS_DECLARATION)
     2397{
     2398    BEGIN_STUB_FUNCTION();
     2399    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2400
     2401    JSValue scrutinee = stackFrame.args[0].jsValue();
     2402    unsigned tableIndex = stackFrame.args[1].int32();
     2403    CallFrame* callFrame = stackFrame.callFrame;
    23022404    CodeBlock* codeBlock = callFrame->codeBlock();
    23032405
    … …  
    23142416}
    23152417
    2316 void* JITStubs::cti_op_switch_char(STUB_ARGS)
    2317 {
    2318     BEGIN_STUB_FUNCTION();
    2319 
    2320     JSValue scrutinee = ARG_src1;
    2321     unsigned tableIndex = ARG_int2;
    2322     CallFrame* callFrame = ARG_callFrame;
     2418void* JITStubs::cti_op_switch_char(STUB_ARGS_DECLARATION)
     2419{
     2420    BEGIN_STUB_FUNCTION();
     2421    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2422
     2423    JSValue scrutinee = stackFrame.args[0].jsValue();
     2424    unsigned tableIndex = stackFrame.args[1].int32();
     2425    CallFrame* callFrame = stackFrame.callFrame;
    23232426    CodeBlock* codeBlock = callFrame->codeBlock();
    23242427
    … …  
    23342437}
    23352438
    2336 void* JITStubs::cti_op_switch_string(STUB_ARGS)
    2337 {
    2338     BEGIN_STUB_FUNCTION();
    2339 
    2340     JSValue scrutinee = ARG_src1;
    2341     unsigned tableIndex = ARG_int2;
    2342     CallFrame* callFrame = ARG_callFrame;
     2439void* JITStubs::cti_op_switch_string(STUB_ARGS_DECLARATION)
     2440{
     2441    BEGIN_STUB_FUNCTION();
     2442    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2443
     2444    JSValue scrutinee = stackFrame.args[0].jsValue();
     2445    unsigned tableIndex = stackFrame.args[1].int32();
     2446    CallFrame* callFrame = stackFrame.callFrame;
    23432447    CodeBlock* codeBlock = callFrame->codeBlock();
    23442448
    … …  
    23532457}
    23542458
    2355 EncodedJSValue JITStubs::cti_op_del_by_val(STUB_ARGS)
    2356 {
    2357     BEGIN_STUB_FUNCTION();
    2358 
    2359     CallFrame* callFrame = ARG_callFrame;
    2360 
    2361     JSValue baseValue = ARG_src1;
     2459EncodedJSValue JITStubs::cti_op_del_by_val(STUB_ARGS_DECLARATION)
     2460{
     2461    BEGIN_STUB_FUNCTION();
     2462    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2463
     2464    CallFrame* callFrame = stackFrame.callFrame;
     2465
     2466    JSValue baseValue = stackFrame.args[0].jsValue();
    23622467    JSObject* baseObj = baseValue.toObject(callFrame); // may throw
    23632468
    2364     JSValue subscript = ARG_src2;
     2469    JSValue subscript = stackFrame.args[1].jsValue();
    23652470    JSValue result;
    23662471    uint32_t i;
    … …  
    23782483}
    23792484
    2380 void JITStubs::cti_op_put_getter(STUB_ARGS)
    2381 {
    2382     BEGIN_STUB_FUNCTION();
    2383 
    2384     CallFrame* callFrame = ARG_callFrame;
    2385 
    2386     ASSERT(ARG_src1.isObject());
    2387     JSObject* baseObj = asObject(ARG_src1);
    2388     ASSERT(ARG_src3.isObject());
    2389     baseObj->defineGetter(callFrame, *ARG_id2, asObject(ARG_src3));
    2390 }
    2391 
    2392 void JITStubs::cti_op_put_setter(STUB_ARGS)
    2393 {
    2394     BEGIN_STUB_FUNCTION();
    2395 
    2396     CallFrame* callFrame = ARG_callFrame;
    2397 
    2398     ASSERT(ARG_src1.isObject());
    2399     JSObject* baseObj = asObject(ARG_src1);
    2400     ASSERT(ARG_src3.isObject());
    2401     baseObj->defineSetter(callFrame, *ARG_id2, asObject(ARG_src3));
    2402 }
    2403 
    2404 JSObject* JITStubs::cti_op_new_error(STUB_ARGS)
    2405 {
    2406     BEGIN_STUB_FUNCTION();
    2407 
    2408     CallFrame* callFrame = ARG_callFrame;
     2485void JITStubs::cti_op_put_getter(STUB_ARGS_DECLARATION)
     2486{
     2487    BEGIN_STUB_FUNCTION();
     2488    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2489
     2490    CallFrame* callFrame = stackFrame.callFrame;
     2491
     2492    ASSERT(stackFrame.args[0].jsValue().isObject());
     2493    JSObject* baseObj = asObject(stackFrame.args[0].jsValue());
     2494    ASSERT(stackFrame.args[2].jsValue().isObject());
     2495    baseObj->defineGetter(callFrame, stackFrame.args[1].identifier(), asObject(stackFrame.args[2].jsValue()));
     2496}
     2497
     2498void JITStubs::cti_op_put_setter(STUB_ARGS_DECLARATION)
     2499{
     2500    BEGIN_STUB_FUNCTION();
     2501    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2502
     2503    CallFrame* callFrame = stackFrame.callFrame;
     2504
     2505    ASSERT(stackFrame.args[0].jsValue().isObject());
     2506    JSObject* baseObj = asObject(stackFrame.args[0].jsValue());
     2507    ASSERT(stackFrame.args[2].jsValue().isObject());
     2508    baseObj->defineSetter(callFrame, stackFrame.args[1].identifier(), asObject(stackFrame.args[2].jsValue()));
     2509}
     2510
     2511JSObject* JITStubs::cti_op_new_error(STUB_ARGS_DECLARATION)
     2512{
     2513    BEGIN_STUB_FUNCTION();
     2514    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2515
     2516    CallFrame* callFrame = stackFrame.callFrame;
    24092517    CodeBlock* codeBlock = callFrame->codeBlock();
    2410     unsigned type = ARG_int1;
    2411     JSValue message = ARG_src2;
    2412     unsigned bytecodeOffset = ARG_int3;
     2518    unsigned type = stackFrame.args[0].int32();
     2519    JSValue message = stackFrame.args[1].jsValue();
     2520    unsigned bytecodeOffset = stackFrame.args[2].int32();
    24132521
    24142522    unsigned lineNumber = codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset);
    … …  
    24162524}
    24172525
    2418 void JITStubs::cti_op_debug(STUB_ARGS)
    2419 {
    2420     BEGIN_STUB_FUNCTION();
    2421 
    2422     CallFrame* callFrame = ARG_callFrame;
    2423 
    2424     int debugHookID = ARG_int1;
    2425     int firstLine = ARG_int2;
    2426     int lastLine = ARG_int3;
    2427 
    2428     ARG_globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
    2429 }
    2430 
    2431 EncodedJSValue JITStubs::cti_vm_throw(STUB_ARGS)
    2432 {
    2433     BEGIN_STUB_FUNCTION();
    2434 
    2435     CallFrame* callFrame = ARG_callFrame;
     2526void JITStubs::cti_op_debug(STUB_ARGS_DECLARATION)
     2527{
     2528    BEGIN_STUB_FUNCTION();
     2529    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2530
     2531    CallFrame* callFrame = stackFrame.callFrame;
     2532
     2533    int debugHookID = stackFrame.args[0].int32();
     2534    int firstLine = stackFrame.args[1].int32();
     2535    int lastLine = stackFrame.args[2].int32();
     2536
     2537    stackFrame.globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
     2538}
     2539
     2540EncodedJSValue JITStubs::cti_vm_throw(STUB_ARGS_DECLARATION)
     2541{
     2542    BEGIN_STUB_FUNCTION();
     2543    JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS);
     2544
     2545    CallFrame* callFrame = stackFrame.callFrame;
    24362546    CodeBlock* codeBlock = callFrame->codeBlock();
    2437     JSGlobalData* globalData = ARG_globalData;
     2547    JSGlobalData* globalData = stackFrame.globalData;
    24382548
    24392549    unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, globalData->exceptionLocation);
    … …  
    24462556
    24472557    if (!handler) {
    2448         *ARG_exception = exceptionValue;
     2558        *stackFrame.exception = exceptionValue;
    24492559        return JSValue::encode(jsNull());
    24502560    }
    24512561
    2452     ARG_setCallFrame(callFrame);
     2562    stackFrame.callFrame = callFrame;
    24532563    void* catchRoutine = handler->nativeCode.addressForExceptionHandler();
    24542564    ASSERT(catchRoutine);
Note: See TracChangeset for help on using the changeset viewer.