Changeset 37650 in webkit for trunk/JavaScriptCore/VM/CTI.cpp


Ignore:
Timestamp:
Oct 17, 2008, 2:06:42 AM (17 years ago)
Author:
[email protected]
Message:

2008-10-17 Maciej Stachowiak <[email protected]>

Reviewed by Cameron Zwarich.


This patch stops writing the call frame at call and return points;
instead it does so immediately before any CTI call.


0.5% speedup or so on the v8 benchmark


  • VM/CTI.cpp: (JSC::CTI::emitCTICall): (JSC::CTI::compileOpCall): (JSC::CTI::emitSlowScriptCheck): (JSC::CTI::compileBinaryArithOpSlowCase): (JSC::CTI::privateCompileMainPass): (JSC::CTI::privateCompileSlowCases): (JSC::CTI::privateCompile):
  • VM/CTI.h:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/JavaScriptCore/VM/CTI.cpp

    r37647 r37650  
    313313}
    314314
    315 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_j helper)
     315ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_j helper)
    316316{
    317317#if ENABLE(SAMPLING_TOOL)
     
    319319#endif
    320320    m_jit.emitRestoreArgumentReference();
     321    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    321322    X86Assembler::JmpSrc call = m_jit.emitCall();
    322323    m_calls.append(CallRecord(call, helper, opcodeIndex));
     
    328329}
    329330
    330 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_p helper)
     331ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_p helper)
    331332{
    332333#if ENABLE(SAMPLING_TOOL)
     
    334335#endif
    335336    m_jit.emitRestoreArgumentReference();
     337    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    336338    X86Assembler::JmpSrc call = m_jit.emitCall();
    337339    m_calls.append(CallRecord(call, helper, opcodeIndex));
     
    343345}
    344346
    345 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_b helper)
     347ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_b helper)
    346348{
    347349#if ENABLE(SAMPLING_TOOL)
     
    349351#endif
    350352    m_jit.emitRestoreArgumentReference();
     353    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    351354    X86Assembler::JmpSrc call = m_jit.emitCall();
    352355    m_calls.append(CallRecord(call, helper, opcodeIndex));
     
    358361}
    359362
    360 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_v helper)
     363ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_v helper)
    361364{
    362365#if ENABLE(SAMPLING_TOOL)
     
    364367#endif
    365368    m_jit.emitRestoreArgumentReference();
     369    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    366370    X86Assembler::JmpSrc call = m_jit.emitCall();
    367371    m_calls.append(CallRecord(call, helper, opcodeIndex));
     
    373377}
    374378
    375 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_s helper)
     379ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_s helper)
    376380{
    377381#if ENABLE(SAMPLING_TOOL)
     
    379383#endif
    380384    m_jit.emitRestoreArgumentReference();
     385    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    381386    X86Assembler::JmpSrc call = m_jit.emitCall();
    382387    m_calls.append(CallRecord(call, helper, opcodeIndex));
     
    388393}
    389394
    390 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_2 helper)
     395ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_2 helper)
    391396{
    392397#if ENABLE(SAMPLING_TOOL)
     
    394399#endif
    395400    m_jit.emitRestoreArgumentReference();
     401    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    396402    X86Assembler::JmpSrc call = m_jit.emitCall();
    397403    m_calls.append(CallRecord(call, helper, opcodeIndex));
     
    487493        emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
    488494        emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx); \
    489         emitCall(i, Machine::cti_##name); \
     495        emitCTICall(i, Machine::cti_##name); \
    490496        emitPutResult(instruction[i + 1].u.operand); \
    491497        i += 4; \
     
    496502    case name: { \
    497503        emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
    498         emitCall(i, Machine::cti_##name); \
     504        emitCTICall(i, Machine::cti_##name); \
    499505        emitPutResult(instruction[i + 1].u.operand); \
    500506        i += 3; \
     
    554560    if (type == OpCallEval) {
    555561        emitGetPutArg(callee, 0, X86::ecx);
    556         emitCall(i, Machine::cti_op_call_eval);
     562        emitCTICall(i, Machine::cti_op_call_eval);
    557563
    558564        m_jit.cmpl_i32r(reinterpret_cast<unsigned>(JSImmediate::impossibleValue()), X86::eax);
     
    574580
    575581    // This handles host functions
    576     emitCall(i, ((type == OpConstruct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
     582    emitCTICall(i, ((type == OpConstruct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
    577583
    578584    X86Assembler::JmpSrc wasNotJSFunction = m_jit.emitUnlinkedJmp();
     
    580586
    581587    // This handles JSFunctions
    582     emitCall(i, (type == OpConstruct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
     588    emitCTICall(i, (type == OpConstruct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
    583589
    584590    compileOpCallInitializeCallFrame(callee, argCount);
     
    588594
    589595    // Put the new value of 'callFrame' into edi and onto the stack, too.
    590     emitPutCTIParam(X86::edx, CTI_ARGS_callFrame);
    591596    m_jit.movl_rr(X86::edx, X86::edi);
    592597
     
    665670    m_jit.subl_i8r(1, X86::esi);
    666671    X86Assembler::JmpSrc skipTimeout = m_jit.emitUnlinkedJne();
    667     emitCall(opcodeIndex, Machine::cti_timeout_check);
     672    emitCTICall(opcodeIndex, Machine::cti_timeout_check);
    668673
    669674    emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
     
    892897    emitGetPutArg(src2, 4, X86::ecx);
    893898    if (opcodeID == op_add)
    894         emitCall(i, Machine::cti_op_add);
     899        emitCTICall(i, Machine::cti_op_add);
    895900    else if (opcodeID == op_sub)
    896         emitCall(i, Machine::cti_op_sub);
     901        emitCTICall(i, Machine::cti_op_sub);
    897902    else {
    898903        ASSERT(opcodeID == op_mul);
    899         emitCall(i, Machine::cti_op_mul);
     904        emitCTICall(i, Machine::cti_op_mul);
    900905    }
    901906    emitPutResult(dst);
     
    952957                    emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
    953958                    emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
    954                     emitCall(i, Machine::cti_op_add);
     959                    emitCTICall(i, Machine::cti_op_add);
    955960                    emitPutResult(instruction[i + 1].u.operand);
    956961                }
     
    962967        case op_end: {
    963968            if (m_codeBlock->needsFullScopeChain)
    964                 emitCall(i, Machine::cti_op_end);
     969                emitCTICall(i, Machine::cti_op_end);
    965970            emitGetArg(instruction[i + 1].u.operand, X86::eax);
    966971#if ENABLE(SAMPLING_TOOL)
     
    10391044        }
    10401045        case op_new_object: {
    1041             emitCall(i, Machine::cti_op_new_object);
     1046            emitCTICall(i, Machine::cti_op_new_object);
    10421047            emitPutResult(instruction[i + 1].u.operand);
    10431048            i += 2;
     
    11651170            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    11661171            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
    1167             emitCall(i, Machine::cti_op_del_by_id);
     1172            emitCTICall(i, Machine::cti_op_del_by_id);
    11681173            emitPutResult(instruction[i + 1].u.operand);
    11691174            i += 4;
     
    12041209            FuncDeclNode* func = (m_codeBlock->functions[instruction[i + 2].u.operand]).get();
    12051210            emitPutArgConstant(reinterpret_cast<unsigned>(func), 0);
    1206             emitCall(i, Machine::cti_op_new_func);
     1211            emitCTICall(i, Machine::cti_op_new_func);
    12071212            emitPutResult(instruction[i + 1].u.operand);
    12081213            i += 3;
     
    12581263        case op_tear_off_activation: {
    12591264            emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
    1260             emitCall(i, Machine::cti_op_tear_off_activation);
     1265            emitCTICall(i, Machine::cti_op_tear_off_activation);
    12611266            i += 2;
    12621267            break;
    12631268        }
    12641269        case op_tear_off_arguments: {
    1265             emitCall(i, Machine::cti_op_tear_off_arguments);
     1270            emitCTICall(i, Machine::cti_op_tear_off_arguments);
    12661271            i += 1;
    12671272            break;
     
    12761281            // We could JIT generate the deref, only calling out to C when the refcount hits zero.
    12771282            if (m_codeBlock->needsFullScopeChain)
    1278                 emitCall(i, Machine::cti_op_ret_scopeChain);
     1283                emitCTICall(i, Machine::cti_op_ret_scopeChain);
    12791284
    12801285            // Return the result in %eax.
     
    12861291            // Restore our caller's "r".
    12871292            emitGetArg(RegisterFile::CallerFrame, X86::edi);
    1288             emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    12891293
    12901294            // Return.
     
    12941298            // Profiling hook
    12951299            m_jit.link(profile, m_jit.label());
    1296             emitCall(i, Machine::cti_op_ret_profiler);
     1300            emitCTICall(i, Machine::cti_op_ret_profiler);
    12971301            m_jit.link(m_jit.emitUnlinkedJmp(), profiled);
    12981302
     
    13041308            emitPutArg(X86::edx, 0);
    13051309            emitPutArgConstant(instruction[i + 3].u.operand, 4);
    1306             emitCall(i, Machine::cti_op_new_array);
     1310            emitCTICall(i, Machine::cti_op_new_array);
    13071311            emitPutResult(instruction[i + 1].u.operand);
    13081312            i += 4;
     
    13121316            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
    13131317            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1314             emitCall(i, Machine::cti_op_resolve);
     1318            emitCTICall(i, Machine::cti_op_resolve);
    13151319            emitPutResult(instruction[i + 1].u.operand);
    13161320            i += 3;
     
    13631367            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    13641368            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1365             emitCall(i, Machine::cti_op_resolve_func);
     1369            emitCTICall(i, Machine::cti_op_resolve_func);
    13661370            emitPutResult(instruction[i + 1].u.operand);
    13671371            emitPutResult(instruction[i + 2].u.operand, X86::edx);
     
    14281432            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
    14291433            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1430             emitCall(i, Machine::cti_op_resolve_base);
     1434            emitCTICall(i, Machine::cti_op_resolve_base);
    14311435            emitPutResult(instruction[i + 1].u.operand);
    14321436            i += 3;
     
    14351439        case op_negate: {
    14361440            emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
    1437             emitCall(i, Machine::cti_op_negate);
     1441            emitCTICall(i, Machine::cti_op_negate);
    14381442            emitPutResult(instruction[i + 1].u.operand);
    14391443            i += 3;
     
    14441448            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
    14451449            emitPutArgConstant(instruction[i + 3].u.operand + m_codeBlock->needsFullScopeChain, 4);
    1446             emitCall(i, Machine::cti_op_resolve_skip);
     1450            emitCTICall(i, Machine::cti_op_resolve_skip);
    14471451            emitPutResult(instruction[i + 1].u.operand);
    14481452            i += 4;
     
    14751479            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
    14761480            emitPutArgConstant(reinterpret_cast<unsigned>(instruction + i), 8);
    1477             emitCall(i, Machine::cti_op_resolve_global);
     1481            emitCTICall(i, Machine::cti_op_resolve_global);
    14781482            emitPutResult(instruction[i + 1].u.operand);
    14791483            m_jit.link(end, m_jit.label());
     
    16471651            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    16481652            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1649             emitCall(i, Machine::cti_op_resolve_with_base);
     1653            emitCTICall(i, Machine::cti_op_resolve_with_base);
    16501654            emitPutResult(instruction[i + 1].u.operand);
    16511655            emitPutResult(instruction[i + 2].u.operand, X86::edx);
     
    16561660            FuncExprNode* func = (m_codeBlock->functionExpressions[instruction[i + 2].u.operand]).get();
    16571661            emitPutArgConstant(reinterpret_cast<unsigned>(func), 0);
    1658             emitCall(i, Machine::cti_op_new_func_exp);
     1662            emitCTICall(i, Machine::cti_op_new_func_exp);
    16591663            emitPutResult(instruction[i + 1].u.operand);
    16601664            i += 3;
     
    17361740            RegExp* regExp = m_codeBlock->regexps[instruction[i + 2].u.operand].get();
    17371741            emitPutArgConstant(reinterpret_cast<unsigned>(regExp), 0);
    1738             emitCall(i, Machine::cti_op_new_regexp);
     1742            emitCTICall(i, Machine::cti_op_new_regexp);
    17391743            emitPutResult(instruction[i + 1].u.operand);
    17401744            i += 3;
     
    17571761        case op_throw: {
    17581762            emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
    1759             emitCall(i, Machine::cti_op_throw);
     1763            emitCTICall(i, Machine::cti_op_throw);
    17601764            m_jit.addl_i8r(0x24, X86::esp);
    17611765            m_jit.popl_r(X86::edi);
     
    17671771        case op_get_pnames: {
    17681772            emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
    1769             emitCall(i, Machine::cti_op_get_pnames);
     1773            emitCTICall(i, Machine::cti_op_get_pnames);
    17701774            emitPutResult(instruction[i + 1].u.operand);
    17711775            i += 3;
     
    17751779            emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
    17761780            unsigned target = instruction[i + 3].u.operand;
    1777             emitCall(i, Machine::cti_op_next_pname);
     1781            emitCTICall(i, Machine::cti_op_next_pname);
    17781782            m_jit.testl_rr(X86::eax, X86::eax);
    17791783            X86Assembler::JmpSrc endOfIter = m_jit.emitUnlinkedJe();
     
    17861790        case op_push_scope: {
    17871791            emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
    1788             emitCall(i, Machine::cti_op_push_scope);
     1792            emitCTICall(i, Machine::cti_op_push_scope);
    17891793            i += 2;
    17901794            break;
    17911795        }
    17921796        case op_pop_scope: {
    1793             emitCall(i, Machine::cti_op_pop_scope);
     1797            emitCTICall(i, Machine::cti_op_pop_scope);
    17941798            i += 1;
    17951799            break;
     
    18341838            emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
    18351839            emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
    1836             emitCall(i, Machine::cti_op_in);
     1840            emitCTICall(i, Machine::cti_op_in);
    18371841            emitPutResult(instruction[i + 1].u.operand);
    18381842            i += 4;
     
    18431847            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
    18441848            emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
    1845             emitCall(i, Machine::cti_op_push_new_scope);
     1849            emitCTICall(i, Machine::cti_op_push_new_scope);
    18461850            emitPutResult(instruction[i + 1].u.operand);
    18471851            i += 4;
     
    18571861            unsigned count = instruction[i + 1].u.operand;
    18581862            emitPutArgConstant(count, 0);
    1859             emitCall(i, Machine::cti_op_jmp_scopes);
     1863            emitCTICall(i, Machine::cti_op_jmp_scopes);
    18601864            unsigned target = instruction[i + 2].u.operand;
    18611865            m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJmp(), i + 2 + target));
     
    18671871            emitPutArgConstant(instruction[i + 2].u.operand, 4);
    18681872            emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
    1869             emitCall(i, Machine::cti_op_put_by_index);
     1873            emitCTICall(i, Machine::cti_op_put_by_index);
    18701874            i += 4;
    18711875            break;
     
    18831887            emitGetPutArg(scrutinee, 0, X86::ecx);
    18841888            emitPutArgConstant(tableIndex, 4);
    1885             emitCall(i, Machine::cti_op_switch_imm);
     1889            emitCTICall(i, Machine::cti_op_switch_imm);
    18861890            m_jit.jmp_r(X86::eax);
    18871891            i += 4;
     
    19001904            emitGetPutArg(scrutinee, 0, X86::ecx);
    19011905            emitPutArgConstant(tableIndex, 4);
    1902             emitCall(i, Machine::cti_op_switch_char);
     1906            emitCTICall(i, Machine::cti_op_switch_char);
    19031907            m_jit.jmp_r(X86::eax);
    19041908            i += 4;
     
    19161920            emitGetPutArg(scrutinee, 0, X86::ecx);
    19171921            emitPutArgConstant(tableIndex, 4);
    1918             emitCall(i, Machine::cti_op_switch_string);
     1922            emitCTICall(i, Machine::cti_op_switch_string);
    19191923            m_jit.jmp_r(X86::eax);
    19201924            i += 4;
     
    19241928            emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
    19251929            emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
    1926             emitCall(i, Machine::cti_op_del_by_val);
     1930            emitCTICall(i, Machine::cti_op_del_by_val);
    19271931            emitPutResult(instruction[i + 1].u.operand);
    19281932            i += 4;
     
    19341938            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
    19351939            emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
    1936             emitCall(i, Machine::cti_op_put_getter);
     1940            emitCTICall(i, Machine::cti_op_put_getter);
    19371941            i += 4;
    19381942            break;
     
    19431947            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
    19441948            emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
    1945             emitCall(i, Machine::cti_op_put_setter);
     1949            emitCTICall(i, Machine::cti_op_put_setter);
    19461950            i += 4;
    19471951            break;
     
    19521956            emitPutArgConstant(reinterpret_cast<unsigned>(message), 4);
    19531957            emitPutArgConstant(m_codeBlock->lineNumberForVPC(&instruction[i]), 8);
    1954             emitCall(i, Machine::cti_op_new_error);
     1958            emitCTICall(i, Machine::cti_op_new_error);
    19551959            emitPutResult(instruction[i + 1].u.operand);
    19561960            i += 4;
     
    19611965            emitPutArgConstant(instruction[i + 2].u.operand, 4);
    19621966            emitPutArgConstant(instruction[i + 3].u.operand, 8);
    1963             emitCall(i, Machine::cti_op_debug);
     1967            emitCTICall(i, Machine::cti_op_debug);
    19641968            i += 4;
    19651969            break;
     
    20442048                emitInitRegister(j);
    20452049
    2046             emitCall(i, Machine::cti_op_push_activation);
     2050            emitCTICall(i, Machine::cti_op_push_activation);
    20472051            emitPutResult(instruction[i + 1].u.operand);
    20482052
     
    20512055        }
    20522056        case op_create_arguments: {
    2053             emitCall(i, Machine::cti_op_create_arguments);
     2057            emitCTICall(i, Machine::cti_op_create_arguments);
    20542058            i += 1;
    20552059            break;
     
    20962100        emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
    20972101        emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx); \
    2098         emitCall(i, Machine::cti_##name); \
     2102        emitCTICall(i, Machine::cti_##name); \
    20992103        emitPutResult(instruction[i + 1].u.operand); \
    21002104        i += 4; \
     
    21142118            m_jit.link((++iter)->from, m_jit.label());
    21152119            emitPutArg(X86::eax, 0);
    2116             emitCall(i, Machine::cti_op_convert_this);
     2120            emitCTICall(i, Machine::cti_op_convert_this);
    21172121            emitPutResult(instruction[i + 1].u.operand);
    21182122            i += 2;
     
    21302134                emitGetPutArg(src1, 0, X86::ecx);
    21312135                emitPutArg(X86::edx, 4);
    2132                 emitCall(i, Machine::cti_op_add);
     2136                emitCTICall(i, Machine::cti_op_add);
    21332137                emitPutResult(dst);
    21342138            } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
     
    21392143                emitPutArg(X86::eax, 0);
    21402144                emitGetPutArg(src2, 4, X86::ecx);
    2141                 emitCall(i, Machine::cti_op_add);
     2145                emitCTICall(i, Machine::cti_op_add);
    21422146                emitPutResult(dst);
    21432147            } else {
     
    21632167            emitPutArg(X86::eax, 0);
    21642168            emitPutArg(X86::edx, 4);
    2165             emitCall(i, Machine::cti_op_get_by_val);
     2169            emitCTICall(i, Machine::cti_op_get_by_val);
    21662170            emitPutResult(instruction[i + 1].u.operand);
    21672171            m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
     
    21932197            emitPutArg(X86::eax, 0);
    21942198            emitPutArg(X86::ecx, 4);
    2195             emitCall(i, Machine::cti_op_rshift);
     2199            emitCTICall(i, Machine::cti_op_rshift);
    21962200            emitPutResult(instruction[i + 1].u.operand);
    21972201            i += 4;
     
    22082212            emitPutArg(X86::eax, 0);
    22092213            emitPutArg(X86::ecx, 4);
    2210             emitCall(i, Machine::cti_op_lshift);
     2214            emitCTICall(i, Machine::cti_op_lshift);
    22112215            emitPutResult(instruction[i + 1].u.operand);
    22122216            i += 4;
     
    22222226                emitPutArg(X86::edx, 0);
    22232227                emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
    2224                 emitCall(i, Machine::cti_op_loop_if_less);
     2228                emitCTICall(i, Machine::cti_op_loop_if_less);
    22252229                m_jit.testl_rr(X86::eax, X86::eax);
    22262230                m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
     
    22302234                emitPutArg(X86::eax, 0);
    22312235                emitPutArg(X86::edx, 4);
    2232                 emitCall(i, Machine::cti_op_loop_if_less);
     2236                emitCTICall(i, Machine::cti_op_loop_if_less);
    22332237                m_jit.testl_rr(X86::eax, X86::eax);
    22342238                m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
     
    22452249            emitPutArg(X86::eax, 0);
    22462250            emitPutArg(X86::edx, 8);
    2247             X86Assembler::JmpSrc call = emitCall(i, Machine::cti_op_put_by_id);
     2251            X86Assembler::JmpSrc call = emitCTICall(i, Machine::cti_op_put_by_id);
    22482252
    22492253            // Track the location of the call; this will be used to recover repatch information.
     
    22712275            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    22722276            emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
    2273             X86Assembler::JmpSrc call = emitCall(i, Machine::cti_op_get_by_id);
     2277            X86Assembler::JmpSrc call = emitCTICall(i, Machine::cti_op_get_by_id);
    22742278            ASSERT(X86Assembler::getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
    22752279            emitPutResult(instruction[i + 1].u.operand);
     
    22972301                emitPutArg(X86::edx, 0);
    22982302                emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
    2299                 emitCall(i, Machine::cti_op_loop_if_lesseq);
     2303                emitCTICall(i, Machine::cti_op_loop_if_lesseq);
    23002304                m_jit.testl_rr(X86::eax, X86::eax);
    23012305                m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
     
    23052309                emitPutArg(X86::eax, 0);
    23062310                emitPutArg(X86::edx, 4);
    2307                 emitCall(i, Machine::cti_op_loop_if_lesseq);
     2311                emitCTICall(i, Machine::cti_op_loop_if_lesseq);
    23082312                m_jit.testl_rr(X86::eax, X86::eax);
    23092313                m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
     
    23192323            m_jit.link(notImm, m_jit.label());
    23202324            emitPutArg(X86::eax, 0);
    2321             emitCall(i, Machine::cti_op_pre_inc);
     2325            emitCTICall(i, Machine::cti_op_pre_inc);
    23222326            emitPutResult(srcDst);
    23232327            i += 2;
     
    23352339            emitPutArg(X86::edx, 4);
    23362340            emitPutArg(X86::ecx, 8);
    2337             emitCall(i, Machine::cti_op_put_by_val);
     2341            emitCTICall(i, Machine::cti_op_put_by_val);
    23382342            m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
    23392343
     
    23452349            emitPutArg(X86::edx, 4);
    23462350            emitPutArg(X86::ecx, 8);
    2347             emitCall(i, Machine::cti_op_put_by_val_array);
     2351            emitCTICall(i, Machine::cti_op_put_by_val_array);
    23482352
    23492353            i += 4;
     
    23552359            m_jit.link(iter->from, m_jit.label());
    23562360            emitPutArg(X86::eax, 0);
    2357             emitCall(i, Machine::cti_op_jtrue);
     2361            emitCTICall(i, Machine::cti_op_jtrue);
    23582362            m_jit.testl_rr(X86::eax, X86::eax);
    23592363            unsigned target = instruction[i + 2].u.operand;
     
    23692373            m_jit.link(notImm, m_jit.label());
    23702374            emitPutArg(X86::eax, 0);
    2371             emitCall(i, Machine::cti_op_pre_dec);
     2375            emitCTICall(i, Machine::cti_op_pre_dec);
    23722376            emitPutResult(srcDst);
    23732377            i += 2;
     
    23812385                emitPutArg(X86::edx, 0);
    23822386                emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
    2383                 emitCall(i, Machine::cti_op_jless);
     2387                emitCTICall(i, Machine::cti_op_jless);
    23842388                m_jit.testl_rr(X86::eax, X86::eax);
    23852389                m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
     
    23892393                emitPutArg(X86::eax, 0);
    23902394                emitPutArg(X86::edx, 4);
    2391                 emitCall(i, Machine::cti_op_jless);
     2395                emitCTICall(i, Machine::cti_op_jless);
    23922396                m_jit.testl_rr(X86::eax, X86::eax);
    23932397                m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
     
    24002404            m_jit.xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
    24012405            emitPutArg(X86::eax, 0);
    2402             emitCall(i, Machine::cti_op_not);
     2406            emitCTICall(i, Machine::cti_op_not);
    24032407            emitPutResult(instruction[i + 1].u.operand);
    24042408            i += 3;
     
    24082412            m_jit.link(iter->from, m_jit.label());
    24092413            emitPutArg(X86::eax, 0);
    2410             emitCall(i, Machine::cti_op_jtrue);
     2414            emitCTICall(i, Machine::cti_op_jtrue);
    24112415            m_jit.testl_rr(X86::eax, X86::eax);
    24122416            unsigned target = instruction[i + 2].u.operand;
     
    24202424            m_jit.link((++iter)->from, m_jit.label());
    24212425            emitPutArg(X86::eax, 0);
    2422             emitCall(i, Machine::cti_op_post_inc);
     2426            emitCTICall(i, Machine::cti_op_post_inc);
    24232427            emitPutResult(instruction[i + 1].u.operand);
    24242428            emitPutResult(srcDst, X86::edx);
     
    24292433            m_jit.link(iter->from, m_jit.label());
    24302434            emitPutArg(X86::eax, 0);
    2431             emitCall(i, Machine::cti_op_bitnot);
     2435            emitCTICall(i, Machine::cti_op_bitnot);
    24322436            emitPutResult(instruction[i + 1].u.operand);
    24332437            i += 3;
     
    24422446                emitGetPutArg(src1, 0, X86::ecx);
    24432447                emitPutArg(X86::eax, 4);
    2444                 emitCall(i, Machine::cti_op_bitand);
     2448                emitCTICall(i, Machine::cti_op_bitand);
    24452449                emitPutResult(dst);
    24462450            } else if (getConstantImmediateNumericArg(src2)) {
     
    24482452                emitPutArg(X86::eax, 0);
    24492453                emitGetPutArg(src2, 4, X86::ecx);
    2450                 emitCall(i, Machine::cti_op_bitand);
     2454                emitCTICall(i, Machine::cti_op_bitand);
    24512455                emitPutResult(dst);
    24522456            } else {
     
    24542458                emitGetPutArg(src1, 0, X86::ecx);
    24552459                emitPutArg(X86::edx, 4);
    2456                 emitCall(i, Machine::cti_op_bitand);
     2460                emitCTICall(i, Machine::cti_op_bitand);
    24572461                emitPutResult(dst);
    24582462            }
     
    24632467            m_jit.link(iter->from, m_jit.label());
    24642468            emitPutArg(X86::eax, 0);
    2465             emitCall(i, Machine::cti_op_jtrue);
     2469            emitCTICall(i, Machine::cti_op_jtrue);
    24662470            m_jit.testl_rr(X86::eax, X86::eax);
    24672471            unsigned target = instruction[i + 2].u.operand;
     
    24752479            m_jit.link((++iter)->from, m_jit.label());
    24762480            emitPutArg(X86::eax, 0);
    2477             emitCall(i, Machine::cti_op_post_dec);
     2481            emitCTICall(i, Machine::cti_op_post_dec);
    24782482            emitPutResult(instruction[i + 1].u.operand);
    24792483            emitPutResult(srcDst, X86::edx);
     
    24852489            emitPutArg(X86::eax, 0);
    24862490            emitPutArg(X86::edx, 4);
    2487             emitCall(i, Machine::cti_op_bitxor);
     2491            emitCTICall(i, Machine::cti_op_bitxor);
    24882492            emitPutResult(instruction[i + 1].u.operand);
    24892493            i += 5;
     
    24942498            emitPutArg(X86::eax, 0);
    24952499            emitPutArg(X86::edx, 4);
    2496             emitCall(i, Machine::cti_op_bitor);
     2500            emitCTICall(i, Machine::cti_op_bitor);
    24972501            emitPutResult(instruction[i + 1].u.operand);
    24982502            i += 5;
     
    25032507            emitPutArg(X86::eax, 0);
    25042508            emitPutArg(X86::edx, 4);
    2505             emitCall(i, Machine::cti_op_eq);
     2509            emitCTICall(i, Machine::cti_op_eq);
    25062510            emitPutResult(instruction[i + 1].u.operand);
    25072511            i += 4;
     
    25122516            emitPutArg(X86::eax, 0);
    25132517            emitPutArg(X86::edx, 4);
    2514             emitCall(i, Machine::cti_op_neq);
     2518            emitCTICall(i, Machine::cti_op_neq);
    25152519            emitPutResult(instruction[i + 1].u.operand);
    25162520            i += 4;
     
    25242528            emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
    25252529            emitGetPutArg(instruction[i + 4].u.operand, 8, X86::ecx);
    2526             emitCall(i, Machine::cti_op_instanceof);
     2530            emitCTICall(i, Machine::cti_op_instanceof);
    25272531            emitPutResult(instruction[i + 1].u.operand);
    25282532            i += 5;
     
    25392543            emitPutArg(X86::eax, 0);
    25402544            emitPutArg(X86::ecx, 4);
    2541             emitCall(i, Machine::cti_op_mod);
     2545            emitCTICall(i, Machine::cti_op_mod);
    25422546            emitPutResult(instruction[i + 1].u.operand);
    25432547            i += 4;
     
    25562560                emitGetPutArg(src1, 0, X86::ecx);
    25572561                emitGetPutArg(src2, 4, X86::ecx);
    2558                 emitCall(i, Machine::cti_op_mul);
     2562                emitCTICall(i, Machine::cti_op_mul);
    25592563                emitPutResult(dst);
    25602564            } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) {
     
    25632567                emitGetPutArg(src1, 0, X86::ecx);
    25642568                emitGetPutArg(src2, 4, X86::ecx);
    2565                 emitCall(i, Machine::cti_op_mul);
     2569                emitCTICall(i, Machine::cti_op_mul);
    25662570                emitPutResult(dst);
    25672571            } else
     
    25772581
    25782582            // We jump to this slow case if the ctiCode for the codeBlock has not yet been generated; compile it now.
    2579             emitCall(i, Machine::cti_vm_compile);
     2583            emitCTICall(i, Machine::cti_vm_compile);
    25802584            emitCall(i, X86::eax);
    25812585
     
    25922596
    25932597            emitPutArg(X86::eax, 0);
    2594             emitCall(i, Machine::cti_op_to_jsnumber);
     2598            emitCTICall(i, Machine::cti_op_to_jsnumber);
    25952599
    25962600            emitPutResult(instruction[i + 1].u.operand);
     
    26322636    if (m_codeBlock->codeType == FunctionCode) {
    26332637        m_jit.link(slowRegisterFileCheck, m_jit.label());
    2634         emitCall(0, Machine::cti_register_file_check);
     2638        emitCTICall(0, Machine::cti_register_file_check);
    26352639        X86Assembler::JmpSrc backToBody = m_jit.emitUnlinkedJmp();
    26362640        m_jit.link(backToBody, afterRegisterFileCheck);
Note: See TracChangeset for help on using the changeset viewer.