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


Ignore:
Timestamp:
Nov 19, 2008, 11:16:30 AM (17 years ago)
Author:
[email protected]
Message:

2008-11-19 Geoffrey Garen <​[email protected]>

Reviewed by Sam Weinig.


A little more refactoring.


Removed the "emit" and "emitUnlinked" prefixes from the assembler.


Moved the JmpSrc and JmpDst class definitions to the top of the X86
assembler class, in accordance with WebKit style guidelines.

  • assembler/X86Assembler.h: (JSC::X86Assembler::JmpSrc::JmpSrc): (JSC::X86Assembler::JmpDst::JmpDst): (JSC::X86Assembler::int3): (JSC::X86Assembler::pushl_m): (JSC::X86Assembler::popl_m): (JSC::X86Assembler::movl_rr): (JSC::X86Assembler::addl_rr): (JSC::X86Assembler::addl_i8r): (JSC::X86Assembler::addl_i8m): (JSC::X86Assembler::addl_i32r): (JSC::X86Assembler::addl_mr): (JSC::X86Assembler::andl_rr): (JSC::X86Assembler::andl_i32r): (JSC::X86Assembler::cmpl_i8r): (JSC::X86Assembler::cmpl_rr): (JSC::X86Assembler::cmpl_rm): (JSC::X86Assembler::cmpl_mr): (JSC::X86Assembler::cmpl_i32r): (JSC::X86Assembler::cmpl_i32m): (JSC::X86Assembler::cmpl_i8m): (JSC::X86Assembler::cmpw_rm): (JSC::X86Assembler::orl_rr): (JSC::X86Assembler::orl_mr): (JSC::X86Assembler::orl_i32r): (JSC::X86Assembler::subl_rr): (JSC::X86Assembler::subl_i8r): (JSC::X86Assembler::subl_i8m): (JSC::X86Assembler::subl_i32r): (JSC::X86Assembler::subl_mr): (JSC::X86Assembler::testl_i32r): (JSC::X86Assembler::testl_i32m): (JSC::X86Assembler::testl_rr): (JSC::X86Assembler::xorl_i8r): (JSC::X86Assembler::xorl_rr): (JSC::X86Assembler::sarl_i8r): (JSC::X86Assembler::sarl_CLr): (JSC::X86Assembler::shl_i8r): (JSC::X86Assembler::shll_CLr): (JSC::X86Assembler::imull_rr): (JSC::X86Assembler::imull_i32r): (JSC::X86Assembler::idivl_r): (JSC::X86Assembler::negl_r): (JSC::X86Assembler::movl_mr): (JSC::X86Assembler::movzbl_rr): (JSC::X86Assembler::movzwl_mr): (JSC::X86Assembler::movl_rm): (JSC::X86Assembler::movl_i32r): (JSC::X86Assembler::movl_i32m): (JSC::X86Assembler::leal_mr): (JSC::X86Assembler::jmp_r): (JSC::X86Assembler::jmp_m): (JSC::X86Assembler::movsd_mr): (JSC::X86Assembler::xorpd_mr): (JSC::X86Assembler::movsd_rm): (JSC::X86Assembler::movd_rr): (JSC::X86Assembler::cvtsi2sd_rr): (JSC::X86Assembler::cvttsd2si_rr): (JSC::X86Assembler::addsd_mr): (JSC::X86Assembler::subsd_mr): (JSC::X86Assembler::mulsd_mr): (JSC::X86Assembler::addsd_rr): (JSC::X86Assembler::subsd_rr): (JSC::X86Assembler::mulsd_rr): (JSC::X86Assembler::ucomis_rr): (JSC::X86Assembler::pextrw_irr): (JSC::X86Assembler::call): (JSC::X86Assembler::jmp): (JSC::X86Assembler::jne): (JSC::X86Assembler::jnz): (JSC::X86Assembler::je): (JSC::X86Assembler::jl): (JSC::X86Assembler::jb): (JSC::X86Assembler::jle): (JSC::X86Assembler::jbe): (JSC::X86Assembler::jge): (JSC::X86Assembler::jg): (JSC::X86Assembler::ja): (JSC::X86Assembler::jae): (JSC::X86Assembler::jo): (JSC::X86Assembler::jp): (JSC::X86Assembler::js): (JSC::X86Assembler::predictNotTaken): (JSC::X86Assembler::convertToFastCall): (JSC::X86Assembler::restoreArgumentReference): (JSC::X86Assembler::restoreArgumentReferenceForTrampoline): (JSC::X86Assembler::modRm_rr): (JSC::X86Assembler::modRm_rr_Unchecked): (JSC::X86Assembler::modRm_rm): (JSC::X86Assembler::modRm_rm_Unchecked): (JSC::X86Assembler::modRm_rmsib): (JSC::X86Assembler::modRm_opr): (JSC::X86Assembler::modRm_opr_Unchecked): (JSC::X86Assembler::modRm_opm): (JSC::X86Assembler::modRm_opm_Unchecked): (JSC::X86Assembler::modRm_opmsib):
  • jit/JIT.cpp: (JSC::JIT::emitNakedCall): (JSC::JIT::emitNakedFastCall): (JSC::JIT::emitCTICall): (JSC::JIT::emitJumpSlowCaseIfNotJSCell): (JSC::JIT::emitJumpSlowCaseIfNotImmNum): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::emitFastArithIntToImmOrSlowCase): (JSC::JIT::emitArithIntToImmWithJump): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpStrictEq): (JSC::JIT::emitSlowScriptCheck): (JSC::JIT::putDoubleResultToJSNumberCellOrJSImmediate): (JSC::JIT::compileBinaryArithOp): (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompile): (JSC::JIT::privateCompileGetByIdSelf): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdChain): (JSC::JIT::privateCompilePutByIdReplace): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompileCTIMachineTrampolines): (JSC::JIT::privateCompilePatchGetArrayLength):
  • wrec/WREC.cpp: (JSC::WREC::compileRegExp):
  • wrec/WRECGenerator.cpp: (JSC::WREC::Generator::generateBackreferenceQuantifier): (JSC::WREC::Generator::generateNonGreedyQuantifier): (JSC::WREC::Generator::generateGreedyQuantifier): (JSC::WREC::Generator::generatePatternCharacter): (JSC::WREC::Generator::generateCharacterClassInvertedRange): (JSC::WREC::Generator::generateCharacterClassInverted): (JSC::WREC::Generator::generateCharacterClass): (JSC::WREC::Generator::generateParentheses): (JSC::WREC::Generator::generateParenthesesNonGreedy): (JSC::WREC::Generator::generateParenthesesResetTrampoline): (JSC::WREC::Generator::generateAssertionBOL): (JSC::WREC::Generator::generateAssertionEOL): (JSC::WREC::Generator::generateAssertionWordBoundary): (JSC::WREC::Generator::generateBackreference): (JSC::WREC::Generator::generateDisjunction):
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/jit/JIT.cpp

    r38590 r38600  
    378378ALWAYS_INLINE JmpSrc JIT::emitNakedCall(unsigned bytecodeIndex, X86::RegisterID r)
    379379{
    380     JmpSrc call = __ emitCall(r);
     380    JmpSrc call = __ call(r);
    381381    m_calls.append(CallRecord(call, bytecodeIndex));
    382382
    … …  
    386386ALWAYS_INLINE  JmpSrc JIT::emitNakedCall(unsigned bytecodeIndex, void* function)
    387387{
    388     JmpSrc call = __ emitCall();
     388    JmpSrc call = __ call();
    389389    m_calls.append(CallRecord(call, reinterpret_cast<CTIHelper_v>(function), bytecodeIndex));
    390390    return call;
    … …  
    393393ALWAYS_INLINE  JmpSrc JIT::emitNakedFastCall(unsigned bytecodeIndex, void* function)
    394394{
    395     JmpSrc call = __ emitCall();
     395    JmpSrc call = __ call();
    396396    m_calls.append(CallRecord(call, reinterpret_cast<CTIHelper_v>(function), bytecodeIndex));
    397397    return call;
    … …  
    405405    UNUSED_PARAM(vPC);
    406406#endif
    407     __ emitRestoreArgumentReference();
     407    __ restoreArgumentReference();
    408408    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    409     JmpSrc call = __ emitCall();
     409    JmpSrc call = __ call();
    410410    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    411411#if ENABLE(OPCODE_SAMPLING)
    … …  
    424424    UNUSED_PARAM(vPC);
    425425#endif
    426     __ emitRestoreArgumentReference();
     426    __ restoreArgumentReference();
    427427    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    428     JmpSrc call = __ emitCall();
     428    JmpSrc call = __ call();
    429429    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    430430#if ENABLE(OPCODE_SAMPLING)
    … …  
    443443    UNUSED_PARAM(vPC);
    444444#endif
    445     __ emitRestoreArgumentReference();
     445    __ restoreArgumentReference();
    446446    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    447     JmpSrc call = __ emitCall();
     447    JmpSrc call = __ call();
    448448    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    449449#if ENABLE(OPCODE_SAMPLING)
    … …  
    462462    UNUSED_PARAM(vPC);
    463463#endif
    464     __ emitRestoreArgumentReference();
     464    __ restoreArgumentReference();
    465465    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    466     JmpSrc call = __ emitCall();
     466    JmpSrc call = __ call();
    467467    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    468468#if ENABLE(OPCODE_SAMPLING)
    … …  
    481481    UNUSED_PARAM(vPC);
    482482#endif
    483     __ emitRestoreArgumentReference();
     483    __ restoreArgumentReference();
    484484    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    485     JmpSrc call = __ emitCall();
     485    JmpSrc call = __ call();
    486486    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    487487#if ENABLE(OPCODE_SAMPLING)
    … …  
    500500    UNUSED_PARAM(vPC);
    501501#endif
    502     __ emitRestoreArgumentReference();
     502    __ restoreArgumentReference();
    503503    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    504     JmpSrc call = __ emitCall();
     504    JmpSrc call = __ call();
    505505    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    506506#if ENABLE(OPCODE_SAMPLING)
    … …  
    519519    UNUSED_PARAM(vPC);
    520520#endif
    521     __ emitRestoreArgumentReference();
     521    __ restoreArgumentReference();
    522522    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    523     JmpSrc call = __ emitCall();
     523    JmpSrc call = __ call();
    524524    m_calls.append(CallRecord(call, helper, bytecodeIndex));
    525525#if ENABLE(OPCODE_SAMPLING)
    … …  
    534534{
    535535    __ testl_i32r(JSImmediate::TagMask, reg);
    536     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), bytecodeIndex));
     536    m_slowCases.append(SlowCaseEntry(__ jne(), bytecodeIndex));
    537537}
    538538
    … …  
    557557{
    558558    __ testl_i32r(JSImmediate::TagBitTypeInteger, reg);
    559     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), bytecodeIndex));
     559    m_slowCases.append(SlowCaseEntry(__ je(), bytecodeIndex));
    560560}
    561561
    … …  
    581581{
    582582    __ subl_i8r(JSImmediate::TagBitTypeInteger, reg);
    583     return __ emitUnlinkedJe();
     583    return __ je();
    584584}
    585585
    … …  
    602602{
    603603    __ addl_rr(reg, reg);
    604     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), bytecodeIndex));
     604    m_slowCases.append(SlowCaseEntry(__ jo(), bytecodeIndex));
    605605    emitFastArithReTagImmediate(reg);
    606606}
    … …  
    615615{
    616616    __ addl_rr(reg, reg);
    617     JmpSrc jmp = __ emitUnlinkedJo();
     617    JmpSrc jmp = __ jo();
    618618    emitFastArithReTagImmediate(reg);
    619619    return jmp;
    … …  
    730730        emitCTICall(instruction, i, Interpreter::cti_op_call_eval);
    731731        __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
    732         wasEval = __ emitUnlinkedJne();
     732        wasEval = __ jne();
    733733    }
    734734
    … …  
    738738    __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::ecx);
    739739    JmpDst addressOfLinkedFunctionCheck = __ label();
    740     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     740    m_slowCases.append(SlowCaseEntry(__ jne(), i));
    741741    ASSERT(X86Assembler::getDifferenceBetweenLabels(addressOfLinkedFunctionCheck, __ label()) == repatchOffsetOpCallCall);
    742742    m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
    … …  
    791791
    792792    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    793     JmpSrc firstNotImmediate = __ emitUnlinkedJe();
     793    JmpSrc firstNotImmediate = __ je();
    794794    __ testl_i32r(JSImmediate::TagMask, X86::edx);
    795     JmpSrc secondNotImmediate = __ emitUnlinkedJe();
     795    JmpSrc secondNotImmediate = __ je();
    796796
    797797    __ cmpl_rr(X86::edx, X86::eax);
    … …  
    803803    emitTagAsBoolImmediate(X86::eax);
    804804           
    805     JmpSrc bothWereImmediates = __ emitUnlinkedJmp();
     805    JmpSrc bothWereImmediates = __ jmp();
    806806
    807807    __ link(firstNotImmediate, __ label());
    … …  
    816816    __ orl_rr(X86::ecx, X86::edx);
    817817
    818     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
     818    m_slowCases.append(SlowCaseEntry(__ jnz(), i));
    819819
    820820    __ movl_i32r(asInteger(jsBoolean(negated)), X86::eax);
    821821
    822     JmpSrc firstWasNotImmediate = __ emitUnlinkedJmp();
     822    JmpSrc firstWasNotImmediate = __ jmp();
    823823
    824824    __ link(secondNotImmediate, __ label());
    825825    // check that eax is not the zero immediate (we know it must be immediate)
    826826    __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
    827     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), i));
     827    m_slowCases.append(SlowCaseEntry(__ je(), i));
    828828
    829829    __ movl_i32r(asInteger(jsBoolean(negated)), X86::eax);
    … …  
    838838{
    839839    __ subl_i8r(1, X86::esi);
    840     JmpSrc skipTimeout = __ emitUnlinkedJne();
     840    JmpSrc skipTimeout = __ jne();
    841841    emitCTICall(vPC, bytecodeIndex, Interpreter::cti_timeout_check);
    842842
    … …  
    867867    // Compare & branch if immediate.
    868868    __ ucomis_rr(tempXmm, xmmSource);
    869     JmpSrc resultIsImm = __ emitUnlinkedJe();
     869    JmpSrc resultIsImm = __ je();
    870870    JmpDst resultLookedLikeImmButActuallyIsnt = __ label();
    871871   
    … …  
    875875        __ movl_rr(jsNumberCell, X86::eax);
    876876    emitPutVirtualRegister(dst);
    877     *wroteJSNumberCell = __ emitUnlinkedJmp();
     877    *wroteJSNumberCell = __ jmp();
    878878
    879879    __ link(resultIsImm, __ label());
    880880    // value == (double)(JSImmediate)value... or at least, it looks that way...
    881881    // ucomi will report that (0 == -0), and will report true if either input in NaN (result is unordered).
    882     __ link(__ emitUnlinkedJp(), resultLookedLikeImmButActuallyIsnt); // Actually was a NaN
     882    __ link(__ jp(), resultLookedLikeImmButActuallyIsnt); // Actually was a NaN
    883883    __ pextrw_irr(3, xmmSource, tempReg2);
    884884    __ cmpl_i32r(0x8000, tempReg2);
    885     __ link(__ emitUnlinkedJe(), resultLookedLikeImmButActuallyIsnt); // Actually was -0
     885    __ link(__ je(), resultLookedLikeImmButActuallyIsnt); // Actually was -0
    886886    // Yes it really really really is representable as a JSImmediate.
    887887    emitFastArithIntToImmNoCheck(tempReg1);
    … …  
    906906        // Check op2 is a number
    907907        __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::edx);
    908         JmpSrc op2imm = __ emitUnlinkedJne();
     908        JmpSrc op2imm = __ jne();
    909909        if (!types.second().definitelyIsNumber()) {
    910910            emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
    911911            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
    912             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     912            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    913913        }
    914914
    … …  
    916916        //     Slow case if src1 is not a number type.
    917917        __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    918         JmpSrc op1imm = __ emitUnlinkedJne();
     918        JmpSrc op1imm = __ jne();
    919919        if (!types.first().definitelyIsNumber()) {
    920920            emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
    921921            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    922             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     922            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    923923        }
    924924
    925925        // (1a) if we get here, src1 is also a number cell
    926926        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
    927         JmpSrc loadedDouble = __ emitUnlinkedJmp();
     927        JmpSrc loadedDouble = __ jmp();
    928928        // (1b) if we get here, src1 is an immediate
    929929        __ link(op1imm, __ label());
    … …  
    942942
    943943        putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::edx, dst, &wasJSNumberCell2, X86::xmm1, X86::ecx, X86::eax);
    944         wasJSNumberCell2b = __ emitUnlinkedJmp();
     944        wasJSNumberCell2b = __ jmp();
    945945
    946946        // (2) This handles cases where src2 is an immediate number.
    … …  
    953953        // Check op1 is a number
    954954        __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    955         JmpSrc op1imm = __ emitUnlinkedJne();
     955        JmpSrc op1imm = __ jne();
    956956        if (!types.first().definitelyIsNumber()) {
    957957            emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
    958958            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    959             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     959            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    960960        }
    961961
    … …  
    963963        //     Slow case if src2 is not a number type.
    964964        __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::edx);
    965         JmpSrc op2imm = __ emitUnlinkedJne();
     965        JmpSrc op2imm = __ jne();
    966966        if (!types.second().definitelyIsNumber()) {
    967967            emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
    968968            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
    969             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     969            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    970970        }
    971971
    972972        // (1a) if we get here, src2 is also a number cell
    973973        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm1);
    974         JmpSrc loadedDouble = __ emitUnlinkedJmp();
     974        JmpSrc loadedDouble = __ jmp();
    975975        // (1b) if we get here, src2 is an immediate
    976976        __ link(op2imm, __ label());
    … …  
    992992
    993993        putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::eax, dst, &wasJSNumberCell1, X86::xmm1, X86::ecx, X86::edx);
    994         wasJSNumberCell1b = __ emitUnlinkedJmp();
     994        wasJSNumberCell1b = __ jmp();
    995995
    996996        // (2) This handles cases where src1 is an immediate number.
    … …  
    10041004        emitFastArithDeTagImmediate(X86::eax);
    10051005        __ addl_rr(X86::edx, X86::eax);
    1006         m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1006        m_slowCases.append(SlowCaseEntry(__ jo(), i));
    10071007    } else  if (opcodeID == op_sub) {
    10081008        __ subl_rr(X86::edx, X86::eax);
    1009         m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1009        m_slowCases.append(SlowCaseEntry(__ jo(), i));
    10101010        emitFastArithReTagImmediate(X86::eax);
    10111011    } else {
    … …  
    10151015        JmpSrc op1Zero = emitFastArithDeTagImmediateJumpIfZero(X86::eax);
    10161016        __ testl_rr(X86::edx, X86::edx);
    1017         JmpSrc op2NonZero = __ emitUnlinkedJne();
     1017        JmpSrc op2NonZero = __ jne();
    10181018        __ link(op1Zero, __ label());
    10191019        // if either input is zero, add the two together, and check if the result is < 0.
    … …  
    10211021        __ movl_rr(X86::eax, X86::ecx);
    10221022        __ addl_rr(X86::edx, X86::ecx);
    1023         m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJs(), i));
     1023        m_slowCases.append(SlowCaseEntry(__ js(), i));
    10241024        // Skip the above check if neither input is zero
    10251025        __ link(op2NonZero, __ label());
    10261026        __ imull_rr(X86::edx, X86::eax);
    1027         m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1027        m_slowCases.append(SlowCaseEntry(__ jo(), i));
    10281028        emitFastArithReTagImmediate(X86::eax);
    10291029    }
    … …  
    11261126                emitJumpSlowCaseIfNotImmNum(X86::eax, i);
    11271127                __ addl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
    1128                 m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1128                m_slowCases.append(SlowCaseEntry(__ jo(), i));
    11291129                emitPutVirtualRegister(dst);
    11301130            } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
    … …  
    11321132                emitJumpSlowCaseIfNotImmNum(X86::eax, i);
    11331133                __ addl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
    1134                 m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1134                m_slowCases.append(SlowCaseEntry(__ jo(), i));
    11351135                emitPutVirtualRegister(dst);
    11361136            } else {
    … …  
    11601160        case op_jmp: {
    11611161            unsigned target = instruction[i + 1].u.operand;
    1162             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 1 + target));
     1162            m_jmpTable.append(JmpTable(__ jmp(), i + 1 + target));
    11631163            i += 2;
    11641164            break;
    … …  
    11691169            emitJumpSlowCaseIfNotImmNum(X86::eax, i);
    11701170            __ addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
    1171             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1171            m_slowCases.append(SlowCaseEntry(__ jo(), i));
    11721172            emitPutVirtualRegister(srcDst);
    11731173            i += 2;
    … …  
    11781178
    11791179            unsigned target = instruction[i + 1].u.operand;
    1180             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 1 + target));
     1180            m_jmpTable.append(JmpTable(__ jmp(), i + 1 + target));
    11811181            i += 2;
    11821182            break;
    … …  
    11911191                emitJumpSlowCaseIfNotImmNum(X86::edx, i);
    11921192                __ cmpl_i32r(asInteger(src2imm), X86::edx);
    1193                 m_jmpTable.append(JmpTable(__ emitUnlinkedJl(), i + 3 + target));
     1193                m_jmpTable.append(JmpTable(__ jl(), i + 3 + target));
    11941194            } else {
    11951195                emitGetVirtualRegisters(instruction[i + 1].u.operand, X86::eax, instruction[i + 2].u.operand, X86::edx, i);
    … …  
    11971197                emitJumpSlowCaseIfNotImmNum(X86::edx, i);
    11981198                __ cmpl_rr(X86::edx, X86::eax);
    1199                 m_jmpTable.append(JmpTable(__ emitUnlinkedJl(), i + 3 + target));
     1199                m_jmpTable.append(JmpTable(__ jl(), i + 3 + target));
    12001200            }
    12011201            i += 4;
    … …  
    12111211                emitJumpSlowCaseIfNotImmNum(X86::edx, i);
    12121212                __ cmpl_i32r(asInteger(src2imm), X86::edx);
    1213                 m_jmpTable.append(JmpTable(__ emitUnlinkedJle(), i + 3 + target));
     1213                m_jmpTable.append(JmpTable(__ jle(), i + 3 + target));
    12141214            } else {
    12151215                emitGetVirtualRegisters(instruction[i + 1].u.operand, X86::eax, instruction[i + 2].u.operand, X86::edx, i);
    … …  
    12171217                emitJumpSlowCaseIfNotImmNum(X86::edx, i);
    12181218                __ cmpl_rr(X86::edx, X86::eax);
    1219                 m_jmpTable.append(JmpTable(__ emitUnlinkedJle(), i + 3 + target));
     1219                m_jmpTable.append(JmpTable(__ jle(), i + 3 + target));
    12201220            }
    12211221            i += 4;
    … …  
    12481248            __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
    12491249            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdStructure);
    1250             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1250            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    12511251
    12521252            // Plant a load from a bogus ofset in the object's property map; we will patch this later, if it is to be used.
    … …  
    12771277            __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
    12781278            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdStructure);
    1279             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1279            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    12801280            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdBranchToSlowCase);
    12811281
    … …  
    12981298            __ testl_i32r(JSImmediate::TagMask, X86::ecx);
    12991299
    1300             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
     1300            m_slowCases.append(SlowCaseEntry(__ jnz(), i));
    13011301
    13021302            // check that all are object type - this is a bit of a bithack to avoid excess branching;
    … …  
    13121312            __ cmpl_rm(X86::ecx, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::edx);
    13131313
    1314             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1314            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    13151315
    13161316            // check that baseVal's flags include ImplementsHasInstance but not OverridesHasInstance
    … …  
    13191319            __ cmpl_i32r(ImplementsHasInstance, X86::ecx);
    13201320
    1321             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1321            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    13221322
    13231323            emitGetVirtualRegister(instruction[i + 2].u.operand, X86::ecx, i); // reload value
    … …  
    13341334           
    13351335            __ cmpl_rr(X86::ecx, X86::edx);
    1336             JmpSrc exit = __ emitUnlinkedJe();
     1336            JmpSrc exit = __ je();
    13371337
    13381338            __ cmpl_i32r(asInteger(jsNull()), X86::ecx);
    1339             JmpSrc goToLoop = __ emitUnlinkedJne();
     1339            JmpSrc goToLoop = __ jne();
    13401340            __ link(goToLoop, loop);
    13411341
    … …  
    13721372                emitFastArithDeTagImmediate(X86::eax);
    13731373                __ imull_i32r(X86::eax, value, X86::eax);
    1374                 m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1374                m_slowCases.append(SlowCaseEntry(__ jo(), i));
    13751375                emitFastArithReTagImmediate(X86::eax);
    13761376                emitPutVirtualRegister(dst);
    … …  
    13801380                emitFastArithDeTagImmediate(X86::eax);
    13811381                __ imull_i32r(X86::eax, value, X86::eax);
    1382                 m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1382                m_slowCases.append(SlowCaseEntry(__ jo(), i));
    13831383                emitFastArithReTagImmediate(X86::eax);
    13841384                emitPutVirtualRegister(dst);
    … …  
    14991499
    15001500            __ testl_i32r(JSImmediate::TagMask, X86::eax);
    1501             JmpSrc isImmediate = __ emitUnlinkedJne();
     1501            JmpSrc isImmediate = __ jne();
    15021502            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
    15031503            __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
    1504             JmpSrc isObject = __ emitUnlinkedJe();
     1504            JmpSrc isObject = __ je();
    15051505
    15061506            __ link(isImmediate, __ label());
    … …  
    15171517            emitFastArithImmToInt(X86::edx);
    15181518            __ testl_i32r(JSImmediate::TagMask, X86::eax);
    1519             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1519            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    15201520            __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
    1521             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1521            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    15221522
    15231523            // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
    15241524            __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
    15251525            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
    1526             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
     1526            m_slowCases.append(SlowCaseEntry(__ jbe(), i));
    15271527
    15281528            // Get the value from the vector
    … …  
    15511551            emitFastArithImmToInt(X86::edx);
    15521552            __ testl_i32r(JSImmediate::TagMask, X86::eax);
    1553             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1553            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    15541554            __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
    1555             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1555            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    15561556
    15571557            // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
    15581558            __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
    15591559            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
    1560             JmpSrc inFastVector = __ emitUnlinkedJa();
     1560            JmpSrc inFastVector = __ ja();
    15611561            // No; oh well, check if the access if within the vector - if so, we may still be okay.
    15621562            __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
    1563             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
     1563            m_slowCases.append(SlowCaseEntry(__ jbe(), i));
    15641564
    15651565            // This is a write to the slow part of the vector; first, we have to check if this would be the first write to this location.
    15661566            // FIXME: should be able to handle initial write to array; increment the the number of items in the array, and potentially update fast access cutoff.
    15671567            __ cmpl_i8m(0, FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
    1568             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), i));
     1568            m_slowCases.append(SlowCaseEntry(__ je(), i));
    15691569
    15701570            // All good - put the value into the array.
    … …  
    15831583
    15841584            __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
    1585             JmpSrc isZero = __ emitUnlinkedJe();
     1585            JmpSrc isZero = __ je();
    15861586            __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    1587             m_jmpTable.append(JmpTable(__ emitUnlinkedJne(), i + 2 + target));
     1587            m_jmpTable.append(JmpTable(__ jne(), i + 2 + target));
    15881588
    15891589            __ cmpl_i32r(asInteger(JSImmediate::trueImmediate()), X86::eax);
    1590             m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
     1590            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
    15911591            __ cmpl_i32r(asInteger(JSImmediate::falseImmediate()), X86::eax);
    1592             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1592            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    15931593
    15941594            __ link(isZero, __ label());
    … …  
    16091609
    16101610            __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    1611             JmpSrc notImmediate = __ emitUnlinkedJe();
     1611            JmpSrc notImmediate = __ je();
    16121612
    16131613            __ cmpl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    1614             JmpSrc zeroImmediate = __ emitUnlinkedJe();
     1614            JmpSrc zeroImmediate = __ je();
    16151615            emitFastArithImmToInt(X86::eax);
    16161616            __ negl_r(X86::eax); // This can't overflow as we only have a 31bit int at this point
    16171617            JmpSrc overflow = emitArithIntToImmWithJump(X86::eax);
    16181618            emitPutVirtualRegister(instruction[i + 1].u.operand);
    1619             JmpSrc immediateNegateSuccess = __ emitUnlinkedJmp();
     1619            JmpSrc immediateNegateSuccess = __ jmp();
    16201620
    16211621            if (!isSSE2Present()) {
    … …  
    16361636                    Structure* numberStructure = m_globalData->numberStructure.get();
    16371637                    __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    1638                     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1638                    m_slowCases.append(SlowCaseEntry(__ jne(), i));
    16391639                }
    16401640                __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
    … …  
    16741674            __ movl_mr(structureAddress, X86::edx);
    16751675            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSCell, m_structure), X86::eax);
    1676             JmpSrc noMatch = __ emitUnlinkedJne(); // Structures don't match
     1676            JmpSrc noMatch = __ jne(); // Structures don't match
    16771677
    16781678            // Load cached property
    … …  
    16811681            __ movl_mr(0, X86::eax, X86::edx, sizeof(JSValue*), X86::eax);
    16821682            emitPutVirtualRegister(instruction[i + 1].u.operand);
    1683             JmpSrc end = __ emitUnlinkedJmp();
     1683            JmpSrc end = __ jmp();
    16841684
    16851685            // Slow case
    … …  
    17001700            emitJumpSlowCaseIfNotImmNum(X86::eax, i);
    17011701            __ subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
    1702             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1702            m_slowCases.append(SlowCaseEntry(__ jo(), i));
    17031703            emitPutVirtualRegister(srcDst);
    17041704            i += 2;
    … …  
    17121712                emitJumpSlowCaseIfNotImmNum(X86::edx, i);
    17131713                __ cmpl_i32r(asInteger(src2imm), X86::edx);
    1714                 m_jmpTable.append(JmpTable(__ emitUnlinkedJge(), i + 3 + target));
     1714                m_jmpTable.append(JmpTable(__ jge(), i + 3 + target));
    17151715            } else {
    17161716                emitGetVirtualRegisters(instruction[i + 1].u.operand, X86::eax, instruction[i + 2].u.operand, X86::edx, i);
    … …  
    17181718                emitJumpSlowCaseIfNotImmNum(X86::edx, i);
    17191719                __ cmpl_rr(X86::edx, X86::eax);
    1720                 m_jmpTable.append(JmpTable(__ emitUnlinkedJge(), i + 3 + target));
     1720                m_jmpTable.append(JmpTable(__ jge(), i + 3 + target));
    17211721            }
    17221722            i += 4;
    … …  
    17271727            __ xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
    17281728            __ testl_i32r(JSImmediate::FullTagTypeMask, X86::eax); // i8?
    1729             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1729            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    17301730            __ xorl_i8r((JSImmediate::FullTagTypeBool | JSImmediate::ExtendedPayloadBitBoolValue), X86::eax);
    17311731            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    17381738
    17391739            __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
    1740             m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
     1740            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
    17411741            __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    1742             JmpSrc isNonZero = __ emitUnlinkedJne();
     1742            JmpSrc isNonZero = __ jne();
    17431743
    17441744            __ cmpl_i32r(asInteger(JSImmediate::falseImmediate()), X86::eax);
    1745             m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
     1745            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
    17461746            __ cmpl_i32r(asInteger(JSImmediate::trueImmediate()), X86::eax);
    1747             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1747            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    17481748
    17491749            __ link(isNonZero, __ label());
    … …  
    17571757            emitGetVirtualRegister(src, X86::eax, i);
    17581758            __ testl_i32r(JSImmediate::TagMask, X86::eax);
    1759             JmpSrc isImmediate = __ emitUnlinkedJnz();
     1759            JmpSrc isImmediate = __ jnz();
    17601760
    17611761            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
    … …  
    17631763            __ setnz_r(X86::eax);
    17641764
    1765             JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
     1765            JmpSrc wasNotImmediate = __ jmp();
    17661766
    17671767            __ link(isImmediate, __ label());
    … …  
    17761776            __ movzbl_rr(X86::eax, X86::eax);
    17771777            __ cmpl_i32r(0, X86::eax);
    1778             m_jmpTable.append(JmpTable(__ emitUnlinkedJnz(), i + 2 + target));           
     1778            m_jmpTable.append(JmpTable(__ jnz(), i + 2 + target));           
    17791779
    17801780            i += 3;
    … …  
    17871787            emitGetVirtualRegister(src, X86::eax, i);
    17881788            __ testl_i32r(JSImmediate::TagMask, X86::eax);
    1789             JmpSrc isImmediate = __ emitUnlinkedJnz();
     1789            JmpSrc isImmediate = __ jnz();
    17901790
    17911791            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
    … …  
    17931793            __ setz_r(X86::eax);
    17941794
    1795             JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
     1795            JmpSrc wasNotImmediate = __ jmp();
    17961796
    17971797            __ link(isImmediate, __ label());
    … …  
    18061806            __ movzbl_rr(X86::eax, X86::eax);
    18071807            __ cmpl_i32r(0, X86::eax);
    1808             m_jmpTable.append(JmpTable(__ emitUnlinkedJnz(), i + 2 + target));           
     1808            m_jmpTable.append(JmpTable(__ jnz(), i + 2 + target));           
    18091809
    18101810            i += 3;
    … …  
    18171817            emitJumpSlowCaseIfNotImmNum(X86::eax, i);
    18181818            __ addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::edx);
    1819             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1819            m_slowCases.append(SlowCaseEntry(__ jo(), i));
    18201820            emitPutVirtualRegister(srcDst, X86::edx);
    18211821            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    18351835            __ movl_i32m(0, sizeof(Register) * retAddrDst, X86::edi);
    18361836            JmpDst addrPosition = __ label();
    1837             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 2 + target));
     1837            m_jmpTable.append(JmpTable(__ jmp(), i + 2 + target));
    18381838            JmpDst sretTarget = __ label();
    18391839            m_jsrSites.append(JSRInfo(addrPosition, sretTarget));
    … …  
    19471947
    19481948            __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
    1949             JmpSrc isZero = __ emitUnlinkedJe();
     1949            JmpSrc isZero = __ je();
    19501950            __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    1951             m_jmpTable.append(JmpTable(__ emitUnlinkedJne(), i + 2 + target));
     1951            m_jmpTable.append(JmpTable(__ jne(), i + 2 + target));
    19521952
    19531953            __ cmpl_i32r(asInteger(JSImmediate::trueImmediate()), X86::eax);
    1954             m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
     1954            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
    19551955            __ cmpl_i32r(asInteger(JSImmediate::falseImmediate()), X86::eax);
    1956             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     1956            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    19571957
    19581958            __ link(isZero, __ label());
    … …  
    19811981            emitJumpSlowCaseIfNotImmNum(X86::eax, i);
    19821982            __ subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::edx);
    1983             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
     1983            m_slowCases.append(SlowCaseEntry(__ jo(), i));
    19841984            emitPutVirtualRegister(srcDst, X86::edx);
    19851985            emitPutVirtualRegister(instruction[i + 1].u.operand);
    … …  
    20362036            emitCTICall(instruction + i, i, Interpreter::cti_op_next_pname);
    20372037            __ testl_rr(X86::eax, X86::eax);
    2038             JmpSrc endOfIter = __ emitUnlinkedJe();
    2039             emitPutVirtualRegister(instruction[i + 1].u.operand);
    2040             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 3 + target));
     2038            JmpSrc endOfIter = __ je();
     2039            emitPutVirtualRegister(instruction[i + 1].u.operand);
     2040            m_jmpTable.append(JmpTable(__ jmp(), i + 3 + target));
    20412041            __ link(endOfIter, __ label());
    20422042            i += 4;
    … …  
    20762076           
    20772077            __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
    2078             JmpSrc wasImmediate = __ emitUnlinkedJnz();
     2078            JmpSrc wasImmediate = __ jnz();
    20792079
    20802080            emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
    … …  
    20832083            __ cmpl_i32m(NumberType, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::ecx);
    20842084           
    2085             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
     2085            m_slowCases.append(SlowCaseEntry(__ jne(), i));
    20862086           
    20872087            __ link(wasImmediate, __ label());
    … …  
    21192119            emitCTICall(instruction + i, i, Interpreter::cti_op_jmp_scopes);
    21202120            unsigned target = instruction[i + 2].u.operand;
    2121             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 2 + target));
     2121            m_jmpTable.append(JmpTable(__ jmp(), i + 2 + target));
    21222122            i += 3;
    21232123            break;
    … …  
    22312231            emitGetVirtualRegister(src1, X86::eax, i);
    22322232            __ testl_i32r(JSImmediate::TagMask, X86::eax);
    2233             JmpSrc isImmediate = __ emitUnlinkedJnz();
     2233            JmpSrc isImmediate = __ jnz();
    22342234
    22352235            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
    … …  
    22372237            __ setnz_r(X86::eax);
    22382238
    2239             JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
     2239            JmpSrc wasNotImmediate = __ jmp();
    22402240
    22412241            __ link(isImmediate, __ label());
    … …  
    22612261            emitGetVirtualRegister(src1, X86::eax, i);
    22622262            __ testl_i32r(JSImmediate::TagMask, X86::eax);
    2263             JmpSrc isImmediate = __ emitUnlinkedJnz();
     2263            JmpSrc isImmediate = __ jnz();
    22642264
    22652265            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
    … …  
    22672267            __ setz_r(X86::eax);
    22682268
    2269             JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
     2269            JmpSrc wasNotImmediate = __ jmp();
    22702270
    22712271            __ link(isImmediate, __ label());
    … …  
    23212321            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::edx);
    23222322            __ testl_i32m(NeedsThisConversion, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::edx);
    2323             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
     2323            m_slowCases.append(SlowCaseEntry(__ jnz(), i));
    23242324
    23252325            i += 2;
    … …  
    23292329            emitGetCTIParam(CTI_ARGS_profilerReference, X86::eax);
    23302330            __ cmpl_i32m(0, X86::eax);
    2331             JmpSrc noProfiler = __ emitUnlinkedJe();
     2331            JmpSrc noProfiler = __ je();
    23322332            emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
    23332333            emitCTICall(instruction + i, i, Interpreter::cti_op_profile_will_call);
    … …  
    23402340            emitGetCTIParam(CTI_ARGS_profilerReference, X86::eax);
    23412341            __ cmpl_i32m(0, X86::eax);
    2342             JmpSrc noProfiler = __ emitUnlinkedJe();
     2342            JmpSrc noProfiler = __ je();
    23432343            emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
    23442344            emitCTICall(instruction + i, i, Interpreter::cti_op_profile_did_call);
    … …  
    24682468            emitCTICall(instruction + i, i, Interpreter::cti_op_get_by_val);
    24692469            emitPutVirtualRegister(instruction[i + 1].u.operand);
    2470             __ link(__ emitUnlinkedJmp(), m_labels[i + 4]);
     2470            __ link(__ jmp(), m_labels[i + 4]);
    24712471
    24722472            // This is slow case that handles accesses to arrays above the fast cut-off.
    … …  
    24742474            __ link((++iter)->from, __ label());
    24752475            __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
    2476             __ link(__ emitUnlinkedJbe(), beginGetByValSlow);
     2476            __ link(__ jbe(), beginGetByValSlow);
    24772477
    24782478            // okay, missed the fast region, but it is still in the vector.  Get the value.
    … …  
    24802480            // Check whether the value loaded is zero; if so we need to return undefined.
    24812481            __ testl_rr(X86::ecx, X86::ecx);
    2482             __ link(__ emitUnlinkedJe(), beginGetByValSlow);
     2482            __ link(__ je(), beginGetByValSlow);
    24832483            __ movl_rr(X86::ecx, X86::eax);
    24842484            emitPutVirtualRegister(instruction[i + 1].u.operand, X86::eax);
    … …  
    25432543                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
    25442544                __ testl_rr(X86::eax, X86::eax);
    2545                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
     2545                __ link(__ jne(), m_labels[i + 3 + target]);
    25462546            } else {
    25472547                __ link(iter->from, __ label());
    … …  
    25512551                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
    25522552                __ testl_rr(X86::eax, X86::eax);
    2553                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
     2553                __ link(__ jne(), m_labels[i + 3 + target]);
    25542554            }
    25552555            i += 4;
    … …  
    26152615                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
    26162616                __ testl_rr(X86::eax, X86::eax);
    2617                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
     2617                __ link(__ jne(), m_labels[i + 3 + target]);
    26182618            } else {
    26192619                __ link(iter->from, __ label());
    … …  
    26232623                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
    26242624                __ testl_rr(X86::eax, X86::eax);
    2625                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
     2625                __ link(__ jne(), m_labels[i + 3 + target]);
    26262626            }
    26272627            i += 4;
    … …  
    26522652            emitPutCTIArg(X86::ecx, 8);
    26532653            emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_val);
    2654             __ link(__ emitUnlinkedJmp(), m_labels[i + 4]);
     2654            __ link(__ jmp(), m_labels[i + 4]);
    26552655
    26562656            // slow cases for immediate int accesses to arrays
    … …  
    26742674            __ testl_rr(X86::eax, X86::eax);
    26752675            unsigned target = instruction[i + 2].u.operand;
    2676             __ link(__ emitUnlinkedJne(), m_labels[i + 2 + target]);
     2676            __ link(__ jne(), m_labels[i + 2 + target]);
    26772677            i += 3;
    26782678            break;
    … …  
    26992699                emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
    27002700                __ testl_rr(X86::eax, X86::eax);
    2701                 __ link(__ emitUnlinkedJe(), m_labels[i + 3 + target]);
     2701                __ link(__ je(), m_labels[i + 3 + target]);
    27022702            } else {
    27032703                __ link(iter->from, __ label());
    … …  
    27072707                emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
    27082708                __ testl_rr(X86::eax, X86::eax);
    2709                 __ link(__ emitUnlinkedJe(), m_labels[i + 3 + target]);
     2709                __ link(__ je(), m_labels[i + 3 + target]);
    27102710            }
    27112711            i += 4;
    … …  
    27272727            __ testl_rr(X86::eax, X86::eax);
    27282728            unsigned target = instruction[i + 2].u.operand;
    2729             __ link(__ emitUnlinkedJe(), m_labels[i + 2 + target]); // inverted!
     2729            __ link(__ je(), m_labels[i + 2 + target]); // inverted!
    27302730            i += 3;
    27312731            break;
    … …  
    27822782            __ testl_rr(X86::eax, X86::eax);
    27832783            unsigned target = instruction[i + 2].u.operand;
    2784             __ link(__ emitUnlinkedJne(), m_labels[i + 2 + target]);
     2784            __ link(__ jne(), m_labels[i + 2 + target]);
    27852785            i += 3;
    27862786            break;
    … …  
    29092909            // Fast check for JS function.
    29102910            __ testl_i32r(JSImmediate::TagMask, X86::ecx);
    2911             JmpSrc callLinkFailNotObject = __ emitUnlinkedJne();
     2911            JmpSrc callLinkFailNotObject = __ jne();
    29122912            __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsFunctionVptr), X86::ecx);
    2913             JmpSrc callLinkFailNotJSFunction = __ emitUnlinkedJne();
     2913            JmpSrc callLinkFailNotJSFunction = __ jne();
    29142914
    29152915            // First, in the case of a construct, allocate the new object.
    … …  
    29292929                emitNakedCall(i, m_interpreter->m_ctiVirtualCallPreLink);
    29302930
    2931             JmpSrc storeResultForFirstRun = __ emitUnlinkedJmp();
     2931            JmpSrc storeResultForFirstRun = __ jmp();
    29322932
    29332933            // This is the address for the cold path *after* the first run (which tries to link the call).
    … …  
    29422942            // Check for JSFunctions.
    29432943            __ testl_i32r(JSImmediate::TagMask, X86::ecx);
    2944             JmpSrc isNotObject = __ emitUnlinkedJne();
     2944            JmpSrc isNotObject = __ jne();
    29452945            __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsFunctionVptr), X86::ecx);
    2946             JmpSrc isJSFunction = __ emitUnlinkedJe();
     2946            JmpSrc isJSFunction = __ je();
    29472947
    29482948            // This handles host functions
    … …  
    29522952            __ link(callLinkFailNotJSFunction, notJSFunctionlabel);
    29532953            emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? Interpreter::cti_op_construct_NotJSConstruct : Interpreter::cti_op_call_NotJSFunction));
    2954             JmpSrc wasNotJSFunction = __ emitUnlinkedJmp();
     2954            JmpSrc wasNotJSFunction = __ jmp();
    29552955
    29562956            // Next, handle JSFunctions...
    … …  
    30063006        ASSERT_WITH_MESSAGE(firstTo == iter->to, "Too many jumps linked in slow case codegen.");
    30073007
    3008         __ link(__ emitUnlinkedJmp(), m_labels[i]);
     3008        __ link(__ jmp(), m_labels[i]);
    30093009    }
    30103010
    … …  
    30353035        __ leal_mr(m_codeBlock->numCalleeRegisters * sizeof(Register), X86::edi, X86::edx);
    30363036        __ cmpl_mr(FIELD_OFFSET(RegisterFile, m_end), X86::eax, X86::edx);
    3037         slowRegisterFileCheck = __ emitUnlinkedJg();
     3037        slowRegisterFileCheck = __ jg();
    30383038        afterRegisterFileCheck = __ label();
    30393039    }
    … …  
    30463046        __ link(slowRegisterFileCheck, __ label());
    30473047        emitCTICall(m_codeBlock->instructions.begin(), 0, Interpreter::cti_register_file_check);
    3048         JmpSrc backToBody = __ emitUnlinkedJmp();
     3048        JmpSrc backToBody = __ jmp();
    30493049        __ link(backToBody, afterRegisterFileCheck);
    30503050    }
    … …  
    31163116    // Check eax is an object of the right Structure.
    31173117    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3118     JmpSrc failureCases1 = __ emitUnlinkedJne();
     3118    JmpSrc failureCases1 = __ jne();
    31193119    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    3120     JmpSrc failureCases2 = __ emitUnlinkedJne();
     3120    JmpSrc failureCases2 = __ jne();
    31213121
    31223122    // Checks out okay! - getDirectOffset
    … …  
    31523152    // check eax is an object of the right Structure.
    31533153    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3154     JmpSrc failureCases1 = __ emitUnlinkedJne();
     3154    JmpSrc failureCases1 = __ jne();
    31553155    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    3156     JmpSrc failureCases2 = __ emitUnlinkedJne();
     3156    JmpSrc failureCases2 = __ jne();
    31573157
    31583158    // Check the prototype object's Structure had not changed.
    31593159    Structure** prototypeStructureAddress = &(protoObject->m_structure);
    31603160    __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructure), static_cast<void*>(prototypeStructureAddress));
    3161     JmpSrc failureCases3 = __ emitUnlinkedJne();
     3161    JmpSrc failureCases3 = __ jne();
    31623162
    31633163    // Checks out okay! - getDirectOffset
    31643164    __ movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::eax);
    31653165
    3166     JmpSrc success = __ emitUnlinkedJmp();
     3166    JmpSrc success = __ jmp();
    31673167
    31683168    void* code = __ executableCopy();
    … …  
    31953195    // check eax is an object of the right Structure.
    31963196    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3197     JmpSrc failureCases1 = __ emitUnlinkedJne();
     3197    JmpSrc failureCases1 = __ jne();
    31983198    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    3199     JmpSrc failureCases2 = __ emitUnlinkedJne();
     3199    JmpSrc failureCases2 = __ jne();
    32003200
    32013201    // Check the prototype object's Structure had not changed.
    32023202    Structure** prototypeStructureAddress = &(protoObject->m_structure);
    32033203    __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructure), static_cast<void*>(prototypeStructureAddress));
    3204     JmpSrc failureCases3 = __ emitUnlinkedJne();
     3204    JmpSrc failureCases3 = __ jne();
    32053205
    32063206    // Checks out okay! - getDirectOffset
    … …  
    32303230    // Check eax is an object of the right Structure.
    32313231    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3232     bucketsOfFail.append(__ emitUnlinkedJne());
     3232    bucketsOfFail.append(__ jne());
    32333233    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    3234     bucketsOfFail.append(__ emitUnlinkedJne());
     3234    bucketsOfFail.append(__ jne());
    32353235
    32363236    Structure* currStructure = structure;
    … …  
    32443244        Structure** prototypeStructureAddress = &(protoObject->m_structure);
    32453245        __ cmpl_i32m(reinterpret_cast<uint32_t>(currStructure), static_cast<void*>(prototypeStructureAddress));
    3246         bucketsOfFail.append(__ emitUnlinkedJne());
     3246        bucketsOfFail.append(__ jne());
    32473247    }
    32483248    ASSERT(protoObject);
    … …  
    32533253    __ ret();
    32543254
    3255     bucketsOfFail.append(__ emitUnlinkedJmp());
     3255    bucketsOfFail.append(__ jmp());
    32563256
    32573257    void* code = __ executableCopy();
    … …  
    32703270    // check eax is an object of the right Structure.
    32713271    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3272     JmpSrc failureCases1 = __ emitUnlinkedJne();
     3272    JmpSrc failureCases1 = __ jne();
    32733273    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    3274     JmpSrc failureCases2 = __ emitUnlinkedJne();
     3274    JmpSrc failureCases2 = __ jne();
    32753275
    32763276    // checks out okay! - putDirectOffset
    … …  
    33103310    // check eax is an object of the right Structure.
    33113311    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3312     failureCases.append(__ emitUnlinkedJne());
     3312    failureCases.append(__ jne());
    33133313    __ cmpl_i32m(reinterpret_cast<uint32_t>(oldStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
    3314     failureCases.append(__ emitUnlinkedJne());
     3314    failureCases.append(__ jne());
    33153315    Vector<JmpSrc> successCases;
    33163316
    … …  
    33193319    // proto(ecx) = baseObject->structure()->prototype()
    33203320    __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
    3321     failureCases.append(__ emitUnlinkedJne());
     3321    failureCases.append(__ jne());
    33223322    __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
    33233323   
    … …  
    33263326        // null check the prototype
    33273327        __ cmpl_i32r(asInteger(jsNull()), X86::ecx);
    3328         successCases.append(__ emitUnlinkedJe());
     3328        successCases.append(__ je());
    33293329
    33303330        // Check the structure id
    33313331        __ cmpl_i32m(reinterpret_cast<uint32_t>(it->get()), FIELD_OFFSET(JSCell, m_structure), X86::ecx);
    3332         failureCases.append(__ emitUnlinkedJne());
     3332        failureCases.append(__ jne());
    33333333       
    33343334        __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
    33353335        __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
    3336         failureCases.append(__ emitUnlinkedJne());
     3336        failureCases.append(__ jne());
    33373337        __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
    33383338    }
    33393339
    3340     failureCases.append(__ emitUnlinkedJne());
     3340    failureCases.append(__ jne());
    33413341    for (unsigned i = 0; i < successCases.size(); ++i)
    33423342        __ link(successCases[i], __ label());
    … …  
    33503350        __ pushl_i32(oldStructure->propertyStorageCapacity());
    33513351        __ pushl_r(X86::eax);
    3352         callTarget = __ emitCall();
     3352        callTarget = __ call();
    33533353        __ addl_i32r(3 * sizeof(void*), X86::esp);
    33543354        __ popl_r(X86::edx);
    … …  
    33713371        for (unsigned i = 0; i < failureCases.size(); ++i)
    33723372            __ link(failureCases[i], __ label());
    3373         __ emitRestoreArgumentReferenceForTrampoline();
    3374         failureJump = __ emitUnlinkedJmp();
     3373        __ restoreArgumentReferenceForTrampoline();
     3374        failureJump = __ jmp();
    33753375    }
    33763376
    … …  
    34203420    // Check eax is an array
    34213421    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3422     JmpSrc array_failureCases1 = __ emitUnlinkedJne();
     3422    JmpSrc array_failureCases1 = __ jne();
    34233423    __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
    3424     JmpSrc array_failureCases2 = __ emitUnlinkedJne();
     3424    JmpSrc array_failureCases2 = __ jne();
    34253425
    34263426    // Checks out okay! - get the length from the storage
    … …  
    34293429
    34303430    __ addl_rr(X86::eax, X86::eax);
    3431     JmpSrc array_failureCases3 = __ emitUnlinkedJo();
     3431    JmpSrc array_failureCases3 = __ jo();
    34323432    __ addl_i8r(1, X86::eax);
    34333433   
    … …  
    34403440    // Check eax is a string
    34413441    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3442     JmpSrc string_failureCases1 = __ emitUnlinkedJne();
     3442    JmpSrc string_failureCases1 = __ jne();
    34433443    __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsStringVptr), X86::eax);
    3444     JmpSrc string_failureCases2 = __ emitUnlinkedJne();
     3444    JmpSrc string_failureCases2 = __ jne();
    34453445
    34463446    // Checks out okay! - get the length from the Ustring.
    … …  
    34493449
    34503450    __ addl_rr(X86::eax, X86::eax);
    3451     JmpSrc string_failureCases3 = __ emitUnlinkedJo();
     3451    JmpSrc string_failureCases3 = __ jo();
    34523452    __ addl_i8r(1, X86::eax);
    34533453   
    … …  
    34623462    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
    34633463    __ testl_rr(X86::eax, X86::eax);
    3464     JmpSrc hasCodeBlock1 = __ emitUnlinkedJne();
     3464    JmpSrc hasCodeBlock1 = __ jne();
    34653465    __ popl_r(X86::ebx);
    3466     __ emitRestoreArgumentReference();
     3466    __ restoreArgumentReference();
    34673467    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3468     JmpSrc callJSFunction1 = __ emitCall();
     3468    JmpSrc callJSFunction1 = __ call();
    34693469    emitGetCTIArg(0, X86::ecx);
    34703470    emitGetCTIArg(8, X86::edx);
    … …  
    34743474    // Check argCount matches callee arity.
    34753475    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
    3476     JmpSrc arityCheckOkay1 = __ emitUnlinkedJe();
     3476    JmpSrc arityCheckOkay1 = __ je();
    34773477    __ popl_r(X86::ebx);
    34783478    emitPutCTIArg(X86::ebx, 4);
    34793479    emitPutCTIArg(X86::eax, 12);
    3480     __ emitRestoreArgumentReference();
     3480    __ restoreArgumentReference();
    34813481    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3482     JmpSrc callArityCheck1 = __ emitCall();
     3482    JmpSrc callArityCheck1 = __ call();
    34833483    __ movl_rr(X86::edx, X86::edi);
    34843484    emitGetCTIArg(0, X86::ecx);
    … …  
    34913491    __ popl_r(X86::ebx);
    34923492    emitPutCTIArg(X86::ebx, 4);
    3493     __ emitRestoreArgumentReference();
     3493    __ restoreArgumentReference();
    34943494    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3495     JmpSrc callDontLazyLinkCall = __ emitCall();
     3495    JmpSrc callDontLazyLinkCall = __ call();
    34963496    __ pushl_r(X86::ebx);
    34973497
    … …  
    35043504    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
    35053505    __ testl_rr(X86::eax, X86::eax);
    3506     JmpSrc hasCodeBlock2 = __ emitUnlinkedJne();
     3506    JmpSrc hasCodeBlock2 = __ jne();
    35073507    __ popl_r(X86::ebx);
    3508     __ emitRestoreArgumentReference();
     3508    __ restoreArgumentReference();
    35093509    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3510     JmpSrc callJSFunction2 = __ emitCall();
     3510    JmpSrc callJSFunction2 = __ call();
    35113511    emitGetCTIArg(0, X86::ecx);
    35123512    emitGetCTIArg(8, X86::edx);
    … …  
    35163516    // Check argCount matches callee arity.
    35173517    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
    3518     JmpSrc arityCheckOkay2 = __ emitUnlinkedJe();
     3518    JmpSrc arityCheckOkay2 = __ je();
    35193519    __ popl_r(X86::ebx);
    35203520    emitPutCTIArg(X86::ebx, 4);
    35213521    emitPutCTIArg(X86::eax, 12);
    3522     __ emitRestoreArgumentReference();
     3522    __ restoreArgumentReference();
    35233523    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3524     JmpSrc callArityCheck2 = __ emitCall();
     3524    JmpSrc callArityCheck2 = __ call();
    35253525    __ movl_rr(X86::edx, X86::edi);
    35263526    emitGetCTIArg(0, X86::ecx);
    … …  
    35333533    __ popl_r(X86::ebx);
    35343534    emitPutCTIArg(X86::ebx, 4);
    3535     __ emitRestoreArgumentReference();
     3535    __ restoreArgumentReference();
    35363536    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3537     JmpSrc callLazyLinkCall = __ emitCall();
     3537    JmpSrc callLazyLinkCall = __ call();
    35383538    __ pushl_r(X86::ebx);
    35393539
    … …  
    35463546    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
    35473547    __ testl_rr(X86::eax, X86::eax);
    3548     JmpSrc hasCodeBlock3 = __ emitUnlinkedJne();
     3548    JmpSrc hasCodeBlock3 = __ jne();
    35493549    __ popl_r(X86::ebx);
    3550     __ emitRestoreArgumentReference();
     3550    __ restoreArgumentReference();
    35513551    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3552     JmpSrc callJSFunction3 = __ emitCall();
     3552    JmpSrc callJSFunction3 = __ call();
    35533553    emitGetCTIArg(0, X86::ecx);
    35543554    emitGetCTIArg(8, X86::edx);
    … …  
    35583558    // Check argCount matches callee arity.
    35593559    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
    3560     JmpSrc arityCheckOkay3 = __ emitUnlinkedJe();
     3560    JmpSrc arityCheckOkay3 = __ je();
    35613561    __ popl_r(X86::ebx);
    35623562    emitPutCTIArg(X86::ebx, 4);
    35633563    emitPutCTIArg(X86::eax, 12);
    3564     __ emitRestoreArgumentReference();
     3564    __ restoreArgumentReference();
    35653565    emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
    3566     JmpSrc callArityCheck3 = __ emitCall();
     3566    JmpSrc callArityCheck3 = __ call();
    35673567    __ movl_rr(X86::edx, X86::edi);
    35683568    emitGetCTIArg(0, X86::ecx);
    … …  
    36453645    // Check eax is an array
    36463646    __ testl_i32r(JSImmediate::TagMask, X86::eax);
    3647     JmpSrc failureCases1 = __ emitUnlinkedJne();
     3647    JmpSrc failureCases1 = __ jne();
    36483648    __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
    3649     JmpSrc failureCases2 = __ emitUnlinkedJne();
     3649    JmpSrc failureCases2 = __ jne();
    36503650
    36513651    // Checks out okay! - get the length from the storage
    … …  
    36543654
    36553655    __ cmpl_i32r(JSImmediate::maxImmediateInt, X86::ecx);
    3656     JmpSrc failureCases3 = __ emitUnlinkedJa();
     3656    JmpSrc failureCases3 = __ ja();
    36573657
    36583658    __ addl_rr(X86::ecx, X86::ecx);
    36593659    __ addl_i8r(1, X86::ecx);
    36603660    __ movl_rr(X86::ecx, X86::eax);
    3661     JmpSrc success = __ emitUnlinkedJmp();
     3661    JmpSrc success = __ jmp();
    36623662
    36633663    void* code = __ executableCopy();
Note: See TracChangeset for help on using the changeset viewer.