Changeset 38916 in webkit for trunk/JavaScriptCore/jit/JIT.cpp


Ignore:
Timestamp:
Dec 2, 2008, 1:32:08 PM (17 years ago)
Author:
[email protected]
Message:

2008-12-01 Gavin Barraclough <​[email protected]>

Reviewed by Geoffrey Garen.

Remove unused (sampling only, and derivable) argument to JIT::emitCTICall.
​https://bugs.webkit.org/show_bug.cgi?id=22587

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

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/jit/JIT.cpp

    r38763 r38916  
    398398}
    399399
    400 ALWAYS_INLINE JmpSrc JIT::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_j helper)
     400ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_j helper)
    401401{
    402402#if ENABLE(OPCODE_SAMPLING)
    403     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
    404 #else
    405     UNUSED_PARAM(vPC);
     403    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
    406404#endif
    407405    __ restoreArgumentReference();
    … …  
    410408    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    411409#if ENABLE(OPCODE_SAMPLING)
    412     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
     410    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
    413411#endif
    414412    killLastResultRegister();
    … …  
    417415}
    418416
    419 ALWAYS_INLINE JmpSrc JIT::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_o helper)
     417ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_o helper)
    420418{
    421419#if ENABLE(OPCODE_SAMPLING)
    422     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
    423 #else
    424     UNUSED_PARAM(vPC);
     420    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
    425421#endif
    426422    __ restoreArgumentReference();
    … …  
    429425    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    430426#if ENABLE(OPCODE_SAMPLING)
    431     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
     427    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
    432428#endif
    433429    killLastResultRegister();
    … …  
    436432}
    437433
    438 ALWAYS_INLINE JmpSrc JIT::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_p helper)
     434ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_p helper)
    439435{
    440436#if ENABLE(OPCODE_SAMPLING)
    441     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
    442 #else
    443     UNUSED_PARAM(vPC);
     437    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
    444438#endif
    445439    __ restoreArgumentReference();
    … …  
    448442    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    449443#if ENABLE(OPCODE_SAMPLING)
    450     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
     444    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
    451445#endif
    452446    killLastResultRegister();
    … …  
    455449}
    456450
    457 ALWAYS_INLINE JmpSrc JIT::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_b helper)
     451ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_b helper)
    458452{
    459453#if ENABLE(OPCODE_SAMPLING)
    460     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
    461 #else
    462     UNUSED_PARAM(vPC);
     454    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
    463455#endif
    464456    __ restoreArgumentReference();
    … …  
    467459    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    468460#if ENABLE(OPCODE_SAMPLING)
    469     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
     461    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
    470462#endif
    471463    killLastResultRegister();
    … …  
    474466}
    475467
    476 ALWAYS_INLINE JmpSrc JIT::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_v helper)
     468ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_v helper)
    477469{
    478470#if ENABLE(OPCODE_SAMPLING)
    479     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
    480 #else
    481     UNUSED_PARAM(vPC);
     471    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
    482472#endif
    483473    __ restoreArgumentReference();
    … …  
    486476    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    487477#if ENABLE(OPCODE_SAMPLING)
    488     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
     478    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
    489479#endif
    490480    killLastResultRegister();
    … …  
    493483}
    494484
    495 ALWAYS_INLINE JmpSrc JIT::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_s helper)
     485ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_s helper)
    496486{
    497487#if ENABLE(OPCODE_SAMPLING)
    498     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
    499 #else
    500     UNUSED_PARAM(vPC);
     488    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
    501489#endif
    502490    __ restoreArgumentReference();
    … …  
    505493    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    506494#if ENABLE(OPCODE_SAMPLING)
    507     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
     495    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
    508496#endif
    509497    killLastResultRegister();
    … …  
    512500}
    513501
    514 ALWAYS_INLINE JmpSrc JIT::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_2 helper)
     502ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_2 helper)
    515503{
    516504#if ENABLE(OPCODE_SAMPLING)
    517     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
    518 #else
    519     UNUSED_PARAM(vPC);
     505    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
    520506#endif
    521507    __ restoreArgumentReference();
    … …  
    524510    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    525511#if ENABLE(OPCODE_SAMPLING)
    526     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
     512    __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
    527513#endif
    528514    killLastResultRegister();
    … …  
    649635        emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
    650636        emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
    651         emitCTICall(instruction + i, i, Interpreter::cti_##name); \
     637        emitCTICall(i, Interpreter::cti_##name); \
    652638        emitPutVirtualRegister(instruction[i + 1].u.operand); \
    653639        i += 4; \
    … …  
    658644    case name: { \
    659645        emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
    660         emitCTICall(instruction + i, i, Interpreter::cti_##name); \
     646        emitCTICall(i, Interpreter::cti_##name); \
    661647        emitPutVirtualRegister(instruction[i + 1].u.operand); \
    662648        i += 3; \
    … …  
    734720        compileOpCallEvalSetupArgs(instruction);
    735721
    736         emitCTICall(instruction, i, Interpreter::cti_op_call_eval);
     722        emitCTICall(i, Interpreter::cti_op_call_eval);
    737723        __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
    738724        wasEval = __ jne();
    … …  
    757743        emitPutCTIArg(X86::ecx, 0);
    758744        emitPutCTIArgFromVirtualRegister(proto, 12, X86::eax);
    759         emitCTICall(instruction, i, Interpreter::cti_op_construct_JSConstruct);
     745        emitCTICall(i, Interpreter::cti_op_construct_JSConstruct);
    760746        emitPutVirtualRegister(thisRegister);
    761747        emitGetVirtualRegister(callee, X86::ecx, i);
    … …  
    841827}
    842828
    843 void JIT::emitSlowScriptCheck(Instruction* vPC, unsigned bytecodeIndex)
     829void JIT::emitSlowScriptCheck(unsigned bytecodeIndex)
    844830{
    845831    __ subl_i8r(1, X86::esi);
    846832    JmpSrc skipTimeout = __ jne();
    847     emitCTICall(vPC, bytecodeIndex, Interpreter::cti_timeout_check);
     833    emitCTICall(bytecodeIndex, Interpreter::cti_timeout_check);
    848834
    849835    emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
    … …  
    10461032}
    10471033
    1048 void JIT::compileBinaryArithOpSlowCase(Instruction* vPC, OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
     1034void JIT::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
    10491035{
    10501036    JmpDst here = __ label();
    … …  
    10841070    emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
    10851071    if (opcodeID == op_add)
    1086         emitCTICall(vPC, i, Interpreter::cti_op_add);
     1072        emitCTICall(i, Interpreter::cti_op_add);
    10871073    else if (opcodeID == op_sub)
    1088         emitCTICall(vPC, i, Interpreter::cti_op_sub);
     1074        emitCTICall(i, Interpreter::cti_op_sub);
    10891075    else {
    10901076        ASSERT(opcodeID == op_mul);
    1091         emitCTICall(vPC, i, Interpreter::cti_op_mul);
     1077        emitCTICall(i, Interpreter::cti_op_mul);
    10921078    }
    10931079    emitPutVirtualRegister(dst);
    … …  
    11471133                    emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
    11481134                    emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
    1149                     emitCTICall(instruction + i, i, Interpreter::cti_op_add);
     1135                    emitCTICall(i, Interpreter::cti_op_add);
    11501136                    emitPutVirtualRegister(instruction[i + 1].u.operand);
    11511137                }
    … …  
    11571143        case op_end: {
    11581144            if (m_codeBlock->needsFullScopeChain)
    1159                 emitCTICall(instruction + i, i, Interpreter::cti_op_end);
     1145                emitCTICall(i, Interpreter::cti_op_end);
    11601146            emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
    11611147            __ pushl_m(RegisterFile::ReturnPC * static_cast<int>(sizeof(Register)), X86::edi);
    … …  
    11811167        }
    11821168        case op_loop: {
    1183             emitSlowScriptCheck(instruction + i, i);
     1169            emitSlowScriptCheck(i);
    11841170
    11851171            unsigned target = instruction[i + 1].u.operand;
    … …  
    11891175        }
    11901176        case op_loop_if_less: {
    1191             emitSlowScriptCheck(instruction + i, i);
     1177            emitSlowScriptCheck(i);
    11921178
    11931179            unsigned target = instruction[i + 3].u.operand;
    … …  
    12091195        }
    12101196        case op_loop_if_lesseq: {
    1211             emitSlowScriptCheck(instruction + i, i);
     1197            emitSlowScriptCheck(i);
    12121198
    12131199            unsigned target = instruction[i + 3].u.operand;
    … …  
    12291215        }
    12301216        case op_new_object: {
    1231             emitCTICall(instruction + i, i, Interpreter::cti_op_new_object);
     1217            emitCTICall(i, Interpreter::cti_op_new_object);
    12321218            emitPutVirtualRegister(instruction[i + 1].u.operand);
    12331219            i += 2;
    … …  
    13591345            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    13601346            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
    1361             emitCTICall(instruction + i, i, Interpreter::cti_op_del_by_id);
     1347            emitCTICall(i, Interpreter::cti_op_del_by_id);
    13621348            emitPutVirtualRegister(instruction[i + 1].u.operand);
    13631349            i += 4;
    … …  
    13981384            FuncDeclNode* func = (m_codeBlock->functions[instruction[i + 2].u.operand]).get();
    13991385            emitPutCTIArgConstant(reinterpret_cast<unsigned>(func), 0);
    1400             emitCTICall(instruction + i, i, Interpreter::cti_op_new_func);
     1386            emitCTICall(i, Interpreter::cti_op_new_func);
    14011387            emitPutVirtualRegister(instruction[i + 1].u.operand);
    14021388            i += 3;
    … …  
    14541440        case op_tear_off_activation: {
    14551441            emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
    1456             emitCTICall(instruction + i, i, Interpreter::cti_op_tear_off_activation);
     1442            emitCTICall(i, Interpreter::cti_op_tear_off_activation);
    14571443            i += 2;
    14581444            break;
    14591445        }
    14601446        case op_tear_off_arguments: {
    1461             emitCTICall(instruction + i, i, Interpreter::cti_op_tear_off_arguments);
     1447            emitCTICall(i, Interpreter::cti_op_tear_off_arguments);
    14621448            i += 1;
    14631449            break;
    … …  
    14661452            // We could JIT generate the deref, only calling out to C when the refcount hits zero.
    14671453            if (m_codeBlock->needsFullScopeChain)
    1468                 emitCTICall(instruction + i, i, Interpreter::cti_op_ret_scopeChain);
     1454                emitCTICall(i, Interpreter::cti_op_ret_scopeChain);
    14691455
    14701456            // Return the result in %eax.
    … …  
    14881474            emitPutCTIArg(X86::edx, 0);
    14891475            emitPutCTIArgConstant(instruction[i + 3].u.operand, 4);
    1490             emitCTICall(instruction + i, i, Interpreter::cti_op_new_array);
     1476            emitCTICall(i, Interpreter::cti_op_new_array);
    14911477            emitPutVirtualRegister(instruction[i + 1].u.operand);
    14921478            i += 4;
    … …  
    14961482            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
    14971483            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1498             emitCTICall(instruction + i, i, Interpreter::cti_op_resolve);
     1484            emitCTICall(i, Interpreter::cti_op_resolve);
    14991485            emitPutVirtualRegister(instruction[i + 1].u.operand);
    15001486            i += 3;
    … …  
    15411527            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    15421528            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1543             emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_func);
     1529            emitCTICall(i, Interpreter::cti_op_resolve_func);
    15441530            emitPutVirtualRegister(instruction[i + 2].u.operand, X86::edx);
    15451531            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    15831569        CTI_COMPILE_BINARY_OP(op_lesseq)
    15841570        case op_loop_if_true: {
    1585             emitSlowScriptCheck(instruction + i, i);
     1571            emitSlowScriptCheck(i);
    15861572
    15871573            unsigned target = instruction[i + 2].u.operand;
    … …  
    16051591            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
    16061592            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1607             emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_base);
     1593            emitCTICall(i, Interpreter::cti_op_resolve_base);
    16081594            emitPutVirtualRegister(instruction[i + 1].u.operand);
    16091595            i += 3;
    … …  
    16301616                __ link(notImmediate, __ label());
    16311617                emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
    1632                 emitCTICall(instruction + i, i, Interpreter::cti_op_negate);
     1618                emitCTICall(i, Interpreter::cti_op_negate);
    16331619                emitPutVirtualRegister(instruction[i + 1].u.operand);
    16341620            } else {
    … …  
    16641650            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
    16651651            emitPutCTIArgConstant(instruction[i + 3].u.operand + m_codeBlock->needsFullScopeChain, 4);
    1666             emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_skip);
     1652            emitCTICall(i, Interpreter::cti_op_resolve_skip);
    16671653            emitPutVirtualRegister(instruction[i + 1].u.operand);
    16681654            i += 4;
    … …  
    16941680            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
    16951681            emitPutCTIArgConstant(reinterpret_cast<unsigned>(instruction + i), 8);
    1696             emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_global);
     1682            emitCTICall(i, Interpreter::cti_op_resolve_global);
    16971683            emitPutVirtualRegister(instruction[i + 1].u.operand);
    16981684            __ link(end, __ label());
    … …  
    19201906            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    19211907            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
    1922             emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_with_base);
     1908            emitCTICall(i, Interpreter::cti_op_resolve_with_base);
    19231909            emitPutVirtualRegister(instruction[i + 2].u.operand, X86::edx);
    19241910            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    19291915            FuncExprNode* func = (m_codeBlock->functionExpressions[instruction[i + 2].u.operand]).get();
    19301916            emitPutCTIArgConstant(reinterpret_cast<unsigned>(func), 0);
    1931             emitCTICall(instruction + i, i, Interpreter::cti_op_new_func_exp);
     1917            emitCTICall(i, Interpreter::cti_op_new_func_exp);
    19321918            emitPutVirtualRegister(instruction[i + 1].u.operand);
    19331919            i += 3;
    … …  
    20061992            RegExp* regExp = m_codeBlock->regexps[instruction[i + 2].u.operand].get();
    20071993            emitPutCTIArgConstant(reinterpret_cast<unsigned>(regExp), 0);
    2008             emitCTICall(instruction + i, i, Interpreter::cti_op_new_regexp);
     1994            emitCTICall(i, Interpreter::cti_op_new_regexp);
    20091995            emitPutVirtualRegister(instruction[i + 1].u.operand);
    20101996            i += 3;
    … …  
    20212007        case op_throw: {
    20222008            emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
    2023             emitCTICall(instruction + i, i, Interpreter::cti_op_throw);
     2009            emitCTICall(i, Interpreter::cti_op_throw);
    20242010            __ addl_i8r(0x20, X86::esp);
    20252011            __ popl_r(X86::ebx);
    … …  
    20322018        case op_get_pnames: {
    20332019            emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
    2034             emitCTICall(instruction + i, i, Interpreter::cti_op_get_pnames);
     2020            emitCTICall(i, Interpreter::cti_op_get_pnames);
    20352021            emitPutVirtualRegister(instruction[i + 1].u.operand);
    20362022            i += 3;
    … …  
    20402026            emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
    20412027            unsigned target = instruction[i + 3].u.operand;
    2042             emitCTICall(instruction + i, i, Interpreter::cti_op_next_pname);
     2028            emitCTICall(i, Interpreter::cti_op_next_pname);
    20432029            __ testl_rr(X86::eax, X86::eax);
    20442030            JmpSrc endOfIter = __ je();
    … …  
    20512037        case op_push_scope: {
    20522038            emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
    2053             emitCTICall(instruction + i, i, Interpreter::cti_op_push_scope);
     2039            emitCTICall(i, Interpreter::cti_op_push_scope);
    20542040            i += 2;
    20552041            break;
    20562042        }
    20572043        case op_pop_scope: {
    2058             emitCTICall(instruction + i, i, Interpreter::cti_op_pop_scope);
     2044            emitCTICall(i, Interpreter::cti_op_pop_scope);
    20592045            i += 1;
    20602046            break;
    … …  
    21002086            emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
    21012087            emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
    2102             emitCTICall(instruction + i, i, Interpreter::cti_op_in);
     2088            emitCTICall(i, Interpreter::cti_op_in);
    21032089            emitPutVirtualRegister(instruction[i + 1].u.operand);
    21042090            i += 4;
    … …  
    21092095            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
    21102096            emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
    2111             emitCTICall(instruction + i, i, Interpreter::cti_op_push_new_scope);
     2097            emitCTICall(i, Interpreter::cti_op_push_new_scope);
    21122098            emitPutVirtualRegister(instruction[i + 1].u.operand);
    21132099            i += 4;
    … …  
    21232109            unsigned count = instruction[i + 1].u.operand;
    21242110            emitPutCTIArgConstant(count, 0);
    2125             emitCTICall(instruction + i, i, Interpreter::cti_op_jmp_scopes);
     2111            emitCTICall(i, Interpreter::cti_op_jmp_scopes);
    21262112            unsigned target = instruction[i + 2].u.operand;
    21272113            m_jmpTable.append(JmpTable(__ jmp(), i + 2 + target));
    … …  
    21332119            emitPutCTIArgConstant(instruction[i + 2].u.operand, 4);
    21342120            emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 8, X86::ecx);
    2135             emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_index);
     2121            emitCTICall(i, Interpreter::cti_op_put_by_index);
    21362122            i += 4;
    21372123            break;
    … …  
    21492135            emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
    21502136            emitPutCTIArgConstant(tableIndex, 4);
    2151             emitCTICall(instruction + i, i, Interpreter::cti_op_switch_imm);
     2137            emitCTICall(i, Interpreter::cti_op_switch_imm);
    21522138            __ jmp_r(X86::eax);
    21532139            i += 4;
    … …  
    21662152            emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
    21672153            emitPutCTIArgConstant(tableIndex, 4);
    2168             emitCTICall(instruction + i, i, Interpreter::cti_op_switch_char);
     2154            emitCTICall(i, Interpreter::cti_op_switch_char);
    21692155            __ jmp_r(X86::eax);
    21702156            i += 4;
    … …  
    21822168            emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
    21832169            emitPutCTIArgConstant(tableIndex, 4);
    2184             emitCTICall(instruction + i, i, Interpreter::cti_op_switch_string);
     2170            emitCTICall(i, Interpreter::cti_op_switch_string);
    21852171            __ jmp_r(X86::eax);
    21862172            i += 4;
    … …  
    21902176            emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
    21912177            emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
    2192             emitCTICall(instruction + i, i, Interpreter::cti_op_del_by_val);
     2178            emitCTICall(i, Interpreter::cti_op_del_by_val);
    21932179            emitPutVirtualRegister(instruction[i + 1].u.operand);
    21942180            i += 4;
    … …  
    22002186            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
    22012187            emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 8, X86::ecx);
    2202             emitCTICall(instruction + i, i, Interpreter::cti_op_put_getter);
     2188            emitCTICall(i, Interpreter::cti_op_put_getter);
    22032189            i += 4;
    22042190            break;
    … …  
    22092195            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
    22102196            emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 8, X86::ecx);
    2211             emitCTICall(instruction + i, i, Interpreter::cti_op_put_setter);
     2197            emitCTICall(i, Interpreter::cti_op_put_setter);
    22122198            i += 4;
    22132199            break;
    … …  
    22182204            emitPutCTIArgConstant(asInteger(message), 4);
    22192205            emitPutCTIArgConstant(m_codeBlock->lineNumberForVPC(&instruction[i]), 8);
    2220             emitCTICall(instruction + i, i, Interpreter::cti_op_new_error);
     2206            emitCTICall(i, Interpreter::cti_op_new_error);
    22212207            emitPutVirtualRegister(instruction[i + 1].u.operand);
    22222208            i += 4;
    … …  
    22272213            emitPutCTIArgConstant(instruction[i + 2].u.operand, 4);
    22282214            emitPutCTIArgConstant(instruction[i + 3].u.operand, 8);
    2229             emitCTICall(instruction + i, i, Interpreter::cti_op_debug);
     2215            emitCTICall(i, Interpreter::cti_op_debug);
    22302216            i += 4;
    22312217            break;
    … …  
    23102296                emitInitRegister(j);
    23112297
    2312             emitCTICall(instruction + i, i, Interpreter::cti_op_push_activation);
     2298            emitCTICall(i, Interpreter::cti_op_push_activation);
    23132299            emitPutVirtualRegister(instruction[i + 1].u.operand);
    23142300
    … …  
    23172303        }
    23182304        case op_create_arguments: {
    2319             emitCTICall(instruction + i, i, (m_codeBlock->numParameters == 1) ? Interpreter::cti_op_create_arguments_no_params : Interpreter::cti_op_create_arguments);
     2305            emitCTICall(i, (m_codeBlock->numParameters == 1) ? Interpreter::cti_op_create_arguments_no_params : Interpreter::cti_op_create_arguments);
    23202306            i += 1;
    23212307            break;
    … …  
    23372323            JmpSrc noProfiler = __ je();
    23382324            emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
    2339             emitCTICall(instruction + i, i, Interpreter::cti_op_profile_will_call);
     2325            emitCTICall(i, Interpreter::cti_op_profile_will_call);
    23402326            __ link(noProfiler, __ label());
    23412327
    … …  
    23482334            JmpSrc noProfiler = __ je();
    23492335            emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
    2350             emitCTICall(instruction + i, i, Interpreter::cti_op_profile_did_call);
     2336            emitCTICall(i, Interpreter::cti_op_profile_did_call);
    23512337            __ link(noProfiler, __ label());
    23522338
    … …  
    23872373        emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
    23882374        emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
    2389         emitCTICall(instruction + i, i, Interpreter::cti_##name); \
     2375        emitCTICall(i, Interpreter::cti_##name); \
    23902376        emitPutVirtualRegister(instruction[i + 1].u.operand); \
    23912377        i += 4; \
    … …  
    23992385        emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
    24002386        emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
    2401         emitCTICall(instruction + i, i, Interpreter::cti_##name); \
     2387        emitCTICall(i, Interpreter::cti_##name); \
    24022388        emitPutVirtualRegister(instruction[i + 1].u.operand); \
    24032389        i += 4; \
    … …  
    24252411            __ link((++iter)->from, __ label());
    24262412            emitPutCTIArg(X86::eax, 0);
    2427             emitCTICall(instruction + i, i, Interpreter::cti_op_convert_this);
     2413            emitCTICall(i, Interpreter::cti_op_convert_this);
    24282414            emitPutVirtualRegister(instruction[i + 1].u.operand);
    24292415            i += 2;
    … …  
    24412427                emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
    24422428                emitPutCTIArg(X86::eax, 4);
    2443                 emitCTICall(instruction + i, i, Interpreter::cti_op_add);
     2429                emitCTICall(i, Interpreter::cti_op_add);
    24442430                emitPutVirtualRegister(dst);
    24452431            } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
    … …  
    24502436                emitPutCTIArg(X86::eax, 0);
    24512437                emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
    2452                 emitCTICall(instruction + i, i, Interpreter::cti_op_add);
     2438                emitCTICall(i, Interpreter::cti_op_add);
    24532439                emitPutVirtualRegister(dst);
    24542440            } else {
    24552441                OperandTypes types = OperandTypes::fromInt(instruction[i + 4].u.operand);
    24562442                if (types.first().mightBeNumber() && types.second().mightBeNumber())
    2457                     compileBinaryArithOpSlowCase(instruction + i, op_add, iter, dst, src1, src2, types, i);
     2443                    compileBinaryArithOpSlowCase(op_add, iter, dst, src1, src2, types, i);
    24582444                else
    24592445                    ASSERT_NOT_REACHED();
    … …  
    24742460            emitPutCTIArg(X86::eax, 0);
    24752461            emitPutCTIArg(X86::edx, 4);
    2476             emitCTICall(instruction + i, i, Interpreter::cti_op_get_by_val);
     2462            emitCTICall(i, Interpreter::cti_op_get_by_val);
    24772463            emitPutVirtualRegister(instruction[i + 1].u.operand);
    24782464            __ link(__ jmp(), m_labels[i + 4]);
    … …  
    24962482        }
    24972483        case op_sub: {
    2498             compileBinaryArithOpSlowCase(instruction + i, op_sub, iter, instruction[i + 1].u.operand, instruction[i + 2].u.operand, instruction[i + 3].u.operand, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
     2484            compileBinaryArithOpSlowCase(op_sub, iter, instruction[i + 1].u.operand, instruction[i + 2].u.operand, instruction[i + 3].u.operand, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
    24992485            i += 5;
    25002486            break;
    … …  
    25112497
    25122498            emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
    2513             emitCTICall(instruction + i, i, Interpreter::cti_op_negate);
     2499            emitCTICall(i, Interpreter::cti_op_negate);
    25142500            emitPutVirtualRegister(instruction[i + 1].u.operand);
    25152501            i += 4;
    … …  
    25212507            emitPutCTIArg(X86::eax, 0);
    25222508            emitPutCTIArg(X86::ecx, 4);
    2523             emitCTICall(instruction + i, i, Interpreter::cti_op_rshift);
     2509            emitCTICall(i, Interpreter::cti_op_rshift);
    25242510            emitPutVirtualRegister(instruction[i + 1].u.operand);
    25252511            i += 4;
    … …  
    25352521            emitPutCTIArg(X86::eax, 0);
    25362522            emitPutCTIArg(X86::ecx, 4);
    2537             emitCTICall(instruction + i, i, Interpreter::cti_op_lshift);
     2523            emitCTICall(i, Interpreter::cti_op_lshift);
    25382524            emitPutVirtualRegister(instruction[i + 1].u.operand);
    25392525            i += 4;
    … …  
    25412527        }
    25422528        case op_loop_if_less: {
    2543             emitSlowScriptCheck(instruction + i, i);
     2529            emitSlowScriptCheck(i);
    25442530
    25452531            unsigned target = instruction[i + 3].u.operand;
    … …  
    25492535                emitPutCTIArg(X86::edx, 0);
    25502536                emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
    2551                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
     2537                emitCTICall(i, Interpreter::cti_op_loop_if_less);
    25522538                __ testl_rr(X86::eax, X86::eax);
    25532539                __ link(__ jne(), m_labels[i + 3 + target]);
    … …  
    25572543                emitPutCTIArg(X86::eax, 0);
    25582544                emitPutCTIArg(X86::edx, 4);
    2559                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
     2545                emitCTICall(i, Interpreter::cti_op_loop_if_less);
    25602546                __ testl_rr(X86::eax, X86::eax);
    25612547                __ link(__ jne(), m_labels[i + 3 + target]);
    … …  
    25732559            emitPutCTIArg(X86::eax, 0);
    25742560            emitPutCTIArg(X86::edx, 8);
    2575             JmpSrc call = emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_id);
     2561            JmpSrc call = emitCTICall(i, Interpreter::cti_op_put_by_id);
    25762562
    25772563            // Track the location of the call; this will be used to recover repatch information.
    … …  
    26002586            Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
    26012587            emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
    2602             JmpSrc call = emitCTICall(instruction + i, i, Interpreter::cti_op_get_by_id);
     2588            JmpSrc call = emitCTICall(i, Interpreter::cti_op_get_by_id);
    26032589            ASSERT(X86Assembler::getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
    26042590            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    26132599        }
    26142600        case op_loop_if_lesseq: {
    2615             emitSlowScriptCheck(instruction + i, i);
     2601            emitSlowScriptCheck(i);
    26162602
    26172603            unsigned target = instruction[i + 3].u.operand;
    … …  
    26212607                emitPutCTIArg(X86::edx, 0);
    26222608                emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
    2623                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
     2609                emitCTICall(i, Interpreter::cti_op_loop_if_lesseq);
    26242610                __ testl_rr(X86::eax, X86::eax);
    26252611                __ link(__ jne(), m_labels[i + 3 + target]);
    … …  
    26292615                emitPutCTIArg(X86::eax, 0);
    26302616                emitPutCTIArg(X86::edx, 4);
    2631                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
     2617                emitCTICall(i, Interpreter::cti_op_loop_if_lesseq);
    26322618                __ testl_rr(X86::eax, X86::eax);
    26332619                __ link(__ jne(), m_labels[i + 3 + target]);
    … …  
    26432629            __ link(notImm, __ label());
    26442630            emitPutCTIArg(X86::eax, 0);
    2645             emitCTICall(instruction + i, i, Interpreter::cti_op_pre_inc);
     2631            emitCTICall(i, Interpreter::cti_op_pre_inc);
    26462632            emitPutVirtualRegister(srcDst);
    26472633            i += 2;
    … …  
    26592645            emitPutCTIArg(X86::edx, 4);
    26602646            emitPutCTIArg(X86::ecx, 8);
    2661             emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_val);
     2647            emitCTICall(i, Interpreter::cti_op_put_by_val);
    26622648            __ link(__ jmp(), m_labels[i + 4]);
    26632649
    … …  
    26692655            emitPutCTIArg(X86::edx, 4);
    26702656            emitPutCTIArg(X86::ecx, 8);
    2671             emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_val_array);
     2657            emitCTICall(i, Interpreter::cti_op_put_by_val_array);
    26722658
    26732659            i += 4;
    … …  
    26752661        }
    26762662        case op_loop_if_true: {
    2677             emitSlowScriptCheck(instruction + i, i);
     2663            emitSlowScriptCheck(i);
    26782664
    26792665            __ link(iter->from, __ label());
    26802666            emitPutCTIArg(X86::eax, 0);
    2681             emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
     2667            emitCTICall(i, Interpreter::cti_op_jtrue);
    26822668            __ testl_rr(X86::eax, X86::eax);
    26832669            unsigned target = instruction[i + 2].u.operand;
    … …  
    26932679            __ link(notImm, __ label());
    26942680            emitPutCTIArg(X86::eax, 0);
    2695             emitCTICall(instruction + i, i, Interpreter::cti_op_pre_dec);
     2681            emitCTICall(i, Interpreter::cti_op_pre_dec);
    26962682            emitPutVirtualRegister(srcDst);
    26972683            i += 2;
    … …  
    27052691                emitPutCTIArg(X86::edx, 0);
    27062692                emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
    2707                 emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
     2693                emitCTICall(i, Interpreter::cti_op_jless);
    27082694                __ testl_rr(X86::eax, X86::eax);
    27092695                __ link(__ je(), m_labels[i + 3 + target]);
    … …  
    27132699                emitPutCTIArg(X86::eax, 0);
    27142700                emitPutCTIArg(X86::edx, 4);
    2715                 emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
     2701                emitCTICall(i, Interpreter::cti_op_jless);
    27162702                __ testl_rr(X86::eax, X86::eax);
    27172703                __ link(__ je(), m_labels[i + 3 + target]);
    … …  
    27242710            __ xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
    27252711            emitPutCTIArg(X86::eax, 0);
    2726             emitCTICall(instruction + i, i, Interpreter::cti_op_not);
     2712            emitCTICall(i, Interpreter::cti_op_not);
    27272713            emitPutVirtualRegister(instruction[i + 1].u.operand);
    27282714            i += 3;
    … …  
    27322718            __ link(iter->from, __ label());
    27332719            emitPutCTIArg(X86::eax, 0);
    2734             emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
     2720            emitCTICall(i, Interpreter::cti_op_jtrue);
    27352721            __ testl_rr(X86::eax, X86::eax);
    27362722            unsigned target = instruction[i + 2].u.operand;
    … …  
    27442730            __ link((++iter)->from, __ label());
    27452731            emitPutCTIArg(X86::eax, 0);
    2746             emitCTICall(instruction + i, i, Interpreter::cti_op_post_inc);
     2732            emitCTICall(i, Interpreter::cti_op_post_inc);
    27472733            emitPutVirtualRegister(srcDst, X86::edx);
    27482734            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    27532739            __ link(iter->from, __ label());
    27542740            emitPutCTIArg(X86::eax, 0);
    2755             emitCTICall(instruction + i, i, Interpreter::cti_op_bitnot);
     2741            emitCTICall(i, Interpreter::cti_op_bitnot);
    27562742            emitPutVirtualRegister(instruction[i + 1].u.operand);
    27572743            i += 3;
    … …  
    27662752                emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
    27672753                emitPutCTIArg(X86::eax, 4);
    2768                 emitCTICall(instruction + i, i, Interpreter::cti_op_bitand);
     2754                emitCTICall(i, Interpreter::cti_op_bitand);
    27692755                emitPutVirtualRegister(dst);
    27702756            } else if (getConstantImmediateNumericArg(src2)) {
    … …  
    27722758                emitPutCTIArg(X86::eax, 0);
    27732759                emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
    2774                 emitCTICall(instruction + i, i, Interpreter::cti_op_bitand);
     2760                emitCTICall(i, Interpreter::cti_op_bitand);
    27752761                emitPutVirtualRegister(dst);
    27762762            } else {
    … …  
    27782764                emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
    27792765                emitPutCTIArg(X86::edx, 4);
    2780                 emitCTICall(instruction + i, i, Interpreter::cti_op_bitand);
     2766                emitCTICall(i, Interpreter::cti_op_bitand);
    27812767                emitPutVirtualRegister(dst);
    27822768            }
    … …  
    27872773            __ link(iter->from, __ label());
    27882774            emitPutCTIArg(X86::eax, 0);
    2789             emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
     2775            emitCTICall(i, Interpreter::cti_op_jtrue);
    27902776            __ testl_rr(X86::eax, X86::eax);
    27912777            unsigned target = instruction[i + 2].u.operand;
    … …  
    27992785            __ link((++iter)->from, __ label());
    28002786            emitPutCTIArg(X86::eax, 0);
    2801             emitCTICall(instruction + i, i, Interpreter::cti_op_post_dec);
     2787            emitCTICall(i, Interpreter::cti_op_post_dec);
    28022788            emitPutVirtualRegister(srcDst, X86::edx);
    28032789            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    28092795            emitPutCTIArg(X86::eax, 0);
    28102796            emitPutCTIArg(X86::edx, 4);
    2811             emitCTICall(instruction + i, i, Interpreter::cti_op_bitxor);
     2797            emitCTICall(i, Interpreter::cti_op_bitxor);
    28122798            emitPutVirtualRegister(instruction[i + 1].u.operand);
    28132799            i += 5;
    … …  
    28182804            emitPutCTIArg(X86::eax, 0);
    28192805            emitPutCTIArg(X86::edx, 4);
    2820             emitCTICall(instruction + i, i, Interpreter::cti_op_bitor);
     2806            emitCTICall(i, Interpreter::cti_op_bitor);
    28212807            emitPutVirtualRegister(instruction[i + 1].u.operand);
    28222808            i += 5;
    … …  
    28272813            emitPutCTIArg(X86::eax, 0);
    28282814            emitPutCTIArg(X86::edx, 4);
    2829             emitCTICall(instruction + i, i, Interpreter::cti_op_eq);
     2815            emitCTICall(i, Interpreter::cti_op_eq);
    28302816            emitPutVirtualRegister(instruction[i + 1].u.operand);
    28312817            i += 4;
    … …  
    28362822            emitPutCTIArg(X86::eax, 0);
    28372823            emitPutCTIArg(X86::edx, 4);
    2838             emitCTICall(instruction + i, i, Interpreter::cti_op_neq);
     2824            emitCTICall(i, Interpreter::cti_op_neq);
    28392825            emitPutVirtualRegister(instruction[i + 1].u.operand);
    28402826            i += 4;
    … …  
    28502836            emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
    28512837            emitPutCTIArgFromVirtualRegister(instruction[i + 4].u.operand, 8, X86::ecx);
    2852             emitCTICall(instruction + i, i, Interpreter::cti_op_instanceof);
     2838            emitCTICall(i, Interpreter::cti_op_instanceof);
    28532839            emitPutVirtualRegister(instruction[i + 1].u.operand);
    28542840            i += 5;
    … …  
    28652851            emitPutCTIArg(X86::eax, 0);
    28662852            emitPutCTIArg(X86::ecx, 4);
    2867             emitCTICall(instruction + i, i, Interpreter::cti_op_mod);
     2853            emitCTICall(i, Interpreter::cti_op_mod);
    28682854            emitPutVirtualRegister(instruction[i + 1].u.operand);
    28692855            i += 4;
    … …  
    28832869                emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
    28842870                emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
    2885                 emitCTICall(instruction + i, i, Interpreter::cti_op_mul);
     2871                emitCTICall(i, Interpreter::cti_op_mul);
    28862872                emitPutVirtualRegister(dst);
    28872873            } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) {
    … …  
    28912877                emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
    28922878                emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
    2893                 emitCTICall(instruction + i, i, Interpreter::cti_op_mul);
     2879                emitCTICall(i, Interpreter::cti_op_mul);
    28942880                emitPutVirtualRegister(dst);
    28952881            } else
    2896                 compileBinaryArithOpSlowCase(instruction + i, op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
     2882                compileBinaryArithOpSlowCase(op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
    28972883            i += 5;
    28982884            break;
    … …  
    29232909            // First, in the case of a construct, allocate the new object.
    29242910            if (opcodeID == op_construct) {
    2925                 emitCTICall(instruction, i, Interpreter::cti_op_construct_JSConstruct);
     2911                emitCTICall(i, Interpreter::cti_op_construct_JSConstruct);
    29262912                emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
    29272913                emitGetVirtualRegister(callee, X86::ecx, i);
    … …  
    29592945            __ link(callLinkFailNotObject, notJSFunctionlabel);
    29602946            __ link(callLinkFailNotJSFunction, notJSFunctionlabel);
    2961             emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? Interpreter::cti_op_construct_NotJSConstruct : Interpreter::cti_op_call_NotJSFunction));
     2947            emitCTICall(i, ((opcodeID == op_construct) ? Interpreter::cti_op_construct_NotJSConstruct : Interpreter::cti_op_call_NotJSFunction));
    29622948            JmpSrc wasNotJSFunction = __ jmp();
    29632949
    … …  
    29672953            // First, in the case of a construct, allocate the new object.
    29682954            if (opcodeID == op_construct) {
    2969                 emitCTICall(instruction, i, Interpreter::cti_op_construct_JSConstruct);
     2955                emitCTICall(i, Interpreter::cti_op_construct_JSConstruct);
    29702956                emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
    29712957                emitGetVirtualRegister(callee, X86::ecx, i);
    … …  
    29992985
    30002986            emitPutCTIArg(X86::eax, 0);
    3001             emitCTICall(instruction + i, i, Interpreter::cti_op_to_jsnumber);
     2987            emitCTICall(i, Interpreter::cti_op_to_jsnumber);
    30022988
    30032989            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    30533039    if (m_codeBlock->codeType == FunctionCode) {
    30543040        __ link(slowRegisterFileCheck, __ label());
    3055         emitCTICall(m_codeBlock->instructions.begin(), 0, Interpreter::cti_register_file_check);
     3041        emitCTICall(0, Interpreter::cti_register_file_check);
    30563042        JmpSrc backToBody = __ jmp();
    30573043        __ link(backToBody, afterRegisterFileCheck);
Note: See TracChangeset for help on using the changeset viewer.