<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[38600] trunk/JavaScriptCore</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/38600">38600</a></dd>
<dt>Author</dt> <dd>ggaren@apple.com</dd>
<dt>Date</dt> <dd>2008-11-19 11:16:30 -0800 (Wed, 19 Nov 2008)</dd>
</dl>

<h3>Log Message</h3>
<pre>2008-11-19  Geoffrey Garen  &lt;ggaren@apple.com&gt;

        Reviewed by Sam Weinig.
        
        A little more refactoring.
        
        Removed the &quot;emit&quot; and &quot;emitUnlinked&quot; 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):</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkJavaScriptCoreChangeLog">trunk/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkJavaScriptCoreassemblerX86Assemblerh">trunk/JavaScriptCore/assembler/X86Assembler.h</a></li>
<li><a href="#trunkJavaScriptCorejitJITcpp">trunk/JavaScriptCore/jit/JIT.cpp</a></li>
<li><a href="#trunkJavaScriptCorewrecWRECcpp">trunk/JavaScriptCore/wrec/WREC.cpp</a></li>
<li><a href="#trunkJavaScriptCorewrecWRECGeneratorcpp">trunk/JavaScriptCore/wrec/WRECGenerator.cpp</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/ChangeLog (38599 => 38600)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/ChangeLog        2008-11-19 18:28:57 UTC (rev 38599)
+++ trunk/JavaScriptCore/ChangeLog        2008-11-19 19:16:30 UTC (rev 38600)
</span><span class="lines">@@ -1,3 +1,153 @@
</span><ins>+2008-11-19  Geoffrey Garen  &lt;ggaren@apple.com&gt;
+
+        Reviewed by Sam Weinig.
+        
+        A little more refactoring.
+        
+        Removed the &quot;emit&quot; and &quot;emitUnlinked&quot; 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):
+
</ins><span class="cx"> 2008-11-19  Simon Hausmann  &lt;hausmann@webkit.org&gt;
</span><span class="cx"> 
</span><span class="cx">         Sun CC build fix, removed trailing comman for last enum value.
</span></span></pre></div>
<a id="trunkJavaScriptCoreassemblerX86Assemblerh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/assembler/X86Assembler.h (38599 => 38600)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/assembler/X86Assembler.h        2008-11-19 18:28:57 UTC (rev 38599)
+++ trunk/JavaScriptCore/assembler/X86Assembler.h        2008-11-19 19:16:30 UTC (rev 38600)
</span><span class="lines">@@ -168,6 +168,42 @@
</span><span class="cx">         GROUP11_MOV = 0,
</span><span class="cx">     } OpcodeID;
</span><span class="cx">     
</span><ins>+    // Opaque label types
+    
+    class JmpSrc {
+        friend class X86Assembler;
+    public:
+        JmpSrc()
+            : m_offset(-1)
+        {
+        }
+
+    private:
+        JmpSrc(int offset)
+            : m_offset(offset)
+        {
+        }
+
+        int m_offset;
+    };
+    
+    class JmpDst {
+        friend class X86Assembler;
+    public:
+        JmpDst()
+            : m_offset(-1)
+        {
+        }
+
+    private:
+        JmpDst(int offset)
+            : m_offset(offset)
+        {
+        }
+
+        int m_offset;
+    };
+
</ins><span class="cx">     static const int maxInstructionSize = 16;
</span><span class="cx"> 
</span><span class="cx">     X86Assembler(AssemblerBuffer* m_buffer)
</span><span class="lines">@@ -176,7 +212,7 @@
</span><span class="cx">         m_buffer-&gt;reset();
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitInt3()
</del><ins>+    void int3()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_INT3);
</span><span class="cx">     }
</span><span class="lines">@@ -189,7 +225,7 @@
</span><span class="cx">     void pushl_m(int offset, RegisterID base)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP5_Ev);
</span><del>-        emitModRm_opm(GROUP5_OP_PUSH, base, offset);
</del><ins>+        modRm_opm(GROUP5_OP_PUSH, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void pushl_i32(int imm)
</span><span class="lines">@@ -206,118 +242,118 @@
</span><span class="cx">     void popl_m(int offset, RegisterID base)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1A_Ev);
</span><del>-        emitModRm_opm(GROUP1A_OP_POP, base, offset);
</del><ins>+        modRm_opm(GROUP1A_OP_POP, base, offset);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void movl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_MOV_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void addl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_ADD_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void addl_i8r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opr(GROUP1_OP_ADD, dst);
</del><ins>+        modRm_opr(GROUP1_OP_ADD, dst);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void addl_i8m(int imm, void* addr)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opm(GROUP1_OP_ADD, addr);
</del><ins>+        modRm_opm(GROUP1_OP_ADD, addr);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void addl_i32r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIz);
</span><del>-        emitModRm_opr(GROUP1_OP_ADD, dst);
</del><ins>+        modRm_opr(GROUP1_OP_ADD, dst);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void addl_mr(int offset, RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_ADD_GvEv);
</span><del>-        emitModRm_rm(dst, base, offset);
</del><ins>+        modRm_rm(dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void andl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_AND_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void andl_i32r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIz);
</span><del>-        emitModRm_opr(GROUP1_OP_AND, dst);
</del><ins>+        modRm_opr(GROUP1_OP_AND, dst);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_i8r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opr(GROUP1_OP_CMP, dst);
</del><ins>+        modRm_opr(GROUP1_OP_CMP, dst);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_CMP_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_rm(RegisterID src, int offset, RegisterID base)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_CMP_EvGv);
</span><del>-        emitModRm_rm(src, base, offset);
</del><ins>+        modRm_rm(src, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_mr(int offset, RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_CMP_GvEv);
</span><del>-        emitModRm_rm(dst, base, offset);
</del><ins>+        modRm_rm(dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_i32r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIz);
</span><del>-        emitModRm_opr(GROUP1_OP_CMP, dst);
</del><ins>+        modRm_opr(GROUP1_OP_CMP, dst);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_i32m(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIz);
</span><del>-        emitModRm_opm(GROUP1_OP_CMP, dst);
</del><ins>+        modRm_opm(GROUP1_OP_CMP, dst);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_i32m(int imm, int offset, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIz);
</span><del>-        emitModRm_opm(GROUP1_OP_CMP, dst, offset);
</del><ins>+        modRm_opm(GROUP1_OP_CMP, dst, offset);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_i32m(int imm, void* addr)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIz);
</span><del>-        emitModRm_opm(GROUP1_OP_CMP, addr);
</del><ins>+        modRm_opm(GROUP1_OP_CMP, addr);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cmpl_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opmsib(GROUP1_OP_CMP, base, index, scale, offset);
</del><ins>+        modRm_opmsib(GROUP1_OP_CMP, base, index, scale, offset);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -325,7 +361,7 @@
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(PRE_OPERAND_SIZE);
</span><span class="cx">         m_buffer-&gt;putByte(OP_CMP_EvGv);
</span><del>-        emitModRm_rmsib(src, base, index, scale);
</del><ins>+        modRm_rmsib(src, base, index, scale);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void sete_r(RegisterID dst)
</span><span class="lines">@@ -355,104 +391,104 @@
</span><span class="cx">     void orl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_OR_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void orl_mr(int offset, RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_OR_GvEv);
</span><del>-        emitModRm_rm(dst, base, offset);
</del><ins>+        modRm_rm(dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void orl_i32r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opr(GROUP1_OP_OR, dst);
</del><ins>+        modRm_opr(GROUP1_OP_OR, dst);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void subl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_SUB_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void subl_i8r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opr(GROUP1_OP_SUB, dst);
</del><ins>+        modRm_opr(GROUP1_OP_SUB, dst);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void subl_i8m(int imm, void* addr)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opm(GROUP1_OP_SUB, addr);
</del><ins>+        modRm_opm(GROUP1_OP_SUB, addr);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void subl_i32r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIz);
</span><del>-        emitModRm_opr(GROUP1_OP_SUB, dst);
</del><ins>+        modRm_opr(GROUP1_OP_SUB, dst);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void subl_mr(int offset, RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_SUB_GvEv);
</span><del>-        emitModRm_rm(dst, base, offset);
</del><ins>+        modRm_rm(dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void testl_i32r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><span class="cx">         m_buffer-&gt;putByteUnchecked(OP_GROUP3_EvIz);
</span><del>-        emitModRm_opr_Unchecked(GROUP3_OP_TEST, dst);
</del><ins>+        modRm_opr_Unchecked(GROUP3_OP_TEST, dst);
</ins><span class="cx">         m_buffer-&gt;putIntUnchecked(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void testl_i32m(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP3_EvIz);
</span><del>-        emitModRm_opm(GROUP3_OP_TEST, dst);
</del><ins>+        modRm_opm(GROUP3_OP_TEST, dst);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void testl_i32m(int imm, int offset, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP3_EvIz);
</span><del>-        emitModRm_opm(GROUP3_OP_TEST, dst, offset);
</del><ins>+        modRm_opm(GROUP3_OP_TEST, dst, offset);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void testl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_TEST_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void xorl_i8r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP1_EvIb);
</span><del>-        emitModRm_opr(GROUP1_OP_XOR, dst);
</del><ins>+        modRm_opr(GROUP1_OP_XOR, dst);
</ins><span class="cx">         m_buffer-&gt;putByte(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void xorl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_XOR_EvGv);
</span><del>-        emitModRm_rr(src, dst);
</del><ins>+        modRm_rr(src, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void sarl_i8r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         if (imm == 1) {
</span><span class="cx">             m_buffer-&gt;putByte(OP_GROUP2_Ev1);
</span><del>-            emitModRm_opr(GROUP2_OP_SAR, dst);
</del><ins>+            modRm_opr(GROUP2_OP_SAR, dst);
</ins><span class="cx">         } else {
</span><span class="cx">             m_buffer-&gt;putByte(OP_GROUP2_EvIb);
</span><del>-            emitModRm_opr(GROUP2_OP_SAR, dst);
</del><ins>+            modRm_opr(GROUP2_OP_SAR, dst);
</ins><span class="cx">             m_buffer-&gt;putByte(imm);
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="lines">@@ -460,17 +496,17 @@
</span><span class="cx">     void sarl_CLr(RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP2_EvCL);
</span><del>-        emitModRm_opr(GROUP2_OP_SAR, dst);
</del><ins>+        modRm_opr(GROUP2_OP_SAR, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void shl_i8r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         if (imm == 1) {
</span><span class="cx">             m_buffer-&gt;putByte(OP_GROUP2_Ev1);
</span><del>-            emitModRm_opr(GROUP2_OP_SHL, dst);
</del><ins>+            modRm_opr(GROUP2_OP_SHL, dst);
</ins><span class="cx">         } else {
</span><span class="cx">             m_buffer-&gt;putByte(OP_GROUP2_EvIb);
</span><del>-            emitModRm_opr(GROUP2_OP_SHL, dst);
</del><ins>+            modRm_opr(GROUP2_OP_SHL, dst);
</ins><span class="cx">             m_buffer-&gt;putByte(imm);
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="lines">@@ -478,33 +514,33 @@
</span><span class="cx">     void shll_CLr(RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP2_EvCL);
</span><del>-        emitModRm_opr(GROUP2_OP_SHL, dst);
</del><ins>+        modRm_opr(GROUP2_OP_SHL, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void imull_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_IMUL_GvEv);
</span><del>-        emitModRm_rr(dst, src);
</del><ins>+        modRm_rr(dst, src);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_IMUL_GvEvIz);
</span><del>-        emitModRm_rr(dst, src);
</del><ins>+        modRm_rr(dst, src);
</ins><span class="cx">         m_buffer-&gt;putInt(value);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void idivl_r(RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP3_Ev);
</span><del>-        emitModRm_opr(GROUP3_OP_IDIV, dst);
</del><ins>+        modRm_opr(GROUP3_OP_IDIV, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void negl_r(RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP3_Ev);
</span><del>-        emitModRm_opr(GROUP3_OP_NEG, dst);
</del><ins>+        modRm_opr(GROUP3_OP_NEG, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cdq()
</span><span class="lines">@@ -515,79 +551,79 @@
</span><span class="cx">     void movl_mr(RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_MOV_GvEv);
</span><del>-        emitModRm_rm(dst, base);
</del><ins>+        modRm_rm(dst, base);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movl_mr(int offset, RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><span class="cx">         m_buffer-&gt;putByteUnchecked(OP_MOV_GvEv);
</span><del>-        emitModRm_rm_Unchecked(dst, base, offset);
</del><ins>+        modRm_rm_Unchecked(dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movl_mr(void* addr, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_MOV_GvEv);
</span><del>-        emitModRm_rm(dst, addr);
</del><ins>+        modRm_rm(dst, addr);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_MOV_GvEv);
</span><del>-        emitModRm_rmsib(dst, base, index, scale, offset);
</del><ins>+        modRm_rmsib(dst, base, index, scale, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movzbl_rr(RegisterID src, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MOVZX_GvEb);
</span><del>-        emitModRm_rr(dst, src);
</del><ins>+        modRm_rr(dst, src);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movzwl_mr(int offset, RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MOVZX_GvEw);
</span><del>-        emitModRm_rm(dst, base, offset);
</del><ins>+        modRm_rm(dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movzwl_mr(RegisterID base, RegisterID index, int scale, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MOVZX_GvEw);
</span><del>-        emitModRm_rmsib(dst, base, index, scale);
</del><ins>+        modRm_rmsib(dst, base, index, scale);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MOVZX_GvEw);
</span><del>-        emitModRm_rmsib(dst, base, index, scale, offset);
</del><ins>+        modRm_rmsib(dst, base, index, scale, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movl_rm(RegisterID src, RegisterID base)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_MOV_EvGv);
</span><del>-        emitModRm_rm(src, base);
</del><ins>+        modRm_rm(src, base);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movl_rm(RegisterID src, int offset, RegisterID base)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><span class="cx">         m_buffer-&gt;putByteUnchecked(OP_MOV_EvGv);
</span><del>-        emitModRm_rm_Unchecked(src, base, offset);
</del><ins>+        modRm_rm_Unchecked(src, base, offset);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_MOV_EvGv);
</span><del>-        emitModRm_rmsib(src, base, index, scale, offset);
</del><ins>+        modRm_rmsib(src, base, index, scale, offset);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void movl_i32r(int imm, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP11_EvIz);
</span><del>-        emitModRm_opr(GROUP11_MOV, dst);
</del><ins>+        modRm_opr(GROUP11_MOV, dst);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -595,27 +631,27 @@
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><span class="cx">         m_buffer-&gt;putByteUnchecked(OP_GROUP11_EvIz);
</span><del>-        emitModRm_opm_Unchecked(GROUP11_MOV, base, offset);
</del><ins>+        modRm_opm_Unchecked(GROUP11_MOV, base, offset);
</ins><span class="cx">         m_buffer-&gt;putIntUnchecked(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movl_i32m(int imm, void* addr)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP11_EvIz);
</span><del>-        emitModRm_opm(GROUP11_MOV, addr);
</del><ins>+        modRm_opm(GROUP11_MOV, addr);
</ins><span class="cx">         m_buffer-&gt;putInt(imm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void leal_mr(int offset, RegisterID base, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_LEA);
</span><del>-        emitModRm_rm(dst, base, offset);
</del><ins>+        modRm_rm(dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void leal_mr(int offset, RegisterID index, int scale, RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_LEA);
</span><del>-        emitModRm_rmsib(dst, X86::noBase, index, scale, offset);
</del><ins>+        modRm_rmsib(dst, X86::noBase, index, scale, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void ret()
</span><span class="lines">@@ -626,13 +662,13 @@
</span><span class="cx">     void jmp_r(RegisterID dst)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP5_Ev);
</span><del>-        emitModRm_opr(GROUP5_OP_JMPN, dst);
</del><ins>+        modRm_opr(GROUP5_OP_JMPN, dst);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void jmp_m(int offset, RegisterID base)
</span><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP5_Ev);
</span><del>-        emitModRm_opm(GROUP5_OP_JMPN, base, offset);
</del><ins>+        modRm_opm(GROUP5_OP_JMPN, base, offset);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     void movsd_mr(int offset, RegisterID base, XMMRegisterID dst)
</span><span class="lines">@@ -640,7 +676,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MOVSD_VsdWsd);
</span><del>-        emitModRm_rm((RegisterID)dst, base, offset);
</del><ins>+        modRm_rm((RegisterID)dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void xorpd_mr(void* addr, XMMRegisterID dst)
</span><span class="lines">@@ -648,7 +684,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_66);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_XORPD_VsdWsd);
</span><del>-        emitModRm_rm((RegisterID)dst, addr);
</del><ins>+        modRm_rm((RegisterID)dst, addr);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
</span><span class="lines">@@ -656,7 +692,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MOVSD_WsdVsd);
</span><del>-        emitModRm_rm((RegisterID)src, base, offset);
</del><ins>+        modRm_rm((RegisterID)src, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void movd_rr(XMMRegisterID src, RegisterID dst)
</span><span class="lines">@@ -664,7 +700,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_66);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MOVD_EdVd);
</span><del>-        emitModRm_rr((RegisterID)src, dst);
</del><ins>+        modRm_rr((RegisterID)src, dst);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
</span><span class="lines">@@ -672,7 +708,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_CVTSI2SD_VsdEd);
</span><del>-        emitModRm_rr((RegisterID)dst, src);
</del><ins>+        modRm_rr((RegisterID)dst, src);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
</span><span class="lines">@@ -680,7 +716,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_CVTTSD2SI_GdWsd);
</span><del>-        emitModRm_rr(dst, (RegisterID)src);
</del><ins>+        modRm_rr(dst, (RegisterID)src);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void addsd_mr(int offset, RegisterID base, XMMRegisterID dst)
</span><span class="lines">@@ -688,7 +724,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_ADDSD_VsdWsd);
</span><del>-        emitModRm_rm((RegisterID)dst, base, offset);
</del><ins>+        modRm_rm((RegisterID)dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void subsd_mr(int offset, RegisterID base, XMMRegisterID dst)
</span><span class="lines">@@ -696,7 +732,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_SUBSD_VsdWsd);
</span><del>-        emitModRm_rm((RegisterID)dst, base, offset);
</del><ins>+        modRm_rm((RegisterID)dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void mulsd_mr(int offset, RegisterID base, XMMRegisterID dst)
</span><span class="lines">@@ -704,7 +740,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MULSD_VsdWsd);
</span><del>-        emitModRm_rm((RegisterID)dst, base, offset);
</del><ins>+        modRm_rm((RegisterID)dst, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
</span><span class="lines">@@ -712,7 +748,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_ADDSD_VsdWsd);
</span><del>-        emitModRm_rr((RegisterID)dst, (RegisterID)src);
</del><ins>+        modRm_rr((RegisterID)dst, (RegisterID)src);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void subsd_rr(XMMRegisterID src, XMMRegisterID dst)
</span><span class="lines">@@ -720,7 +756,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_SUBSD_VsdWsd);
</span><del>-        emitModRm_rr((RegisterID)dst, (RegisterID)src);
</del><ins>+        modRm_rr((RegisterID)dst, (RegisterID)src);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void mulsd_rr(XMMRegisterID src, XMMRegisterID dst)
</span><span class="lines">@@ -728,7 +764,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_F2);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_MULSD_VsdWsd);
</span><del>-        emitModRm_rr((RegisterID)dst, (RegisterID)src);
</del><ins>+        modRm_rr((RegisterID)dst, (RegisterID)src);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void ucomis_rr(XMMRegisterID src, XMMRegisterID dst)
</span><span class="lines">@@ -736,7 +772,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_66);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_UCOMISD_VsdWsd);
</span><del>-        emitModRm_rr((RegisterID)dst, (RegisterID)src);
</del><ins>+        modRm_rr((RegisterID)dst, (RegisterID)src);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void pextrw_irr(int whichWord, XMMRegisterID src, RegisterID dst)
</span><span class="lines">@@ -744,58 +780,21 @@
</span><span class="cx">         m_buffer-&gt;putByte(PRE_SSE_66);
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_PEXTRW_GdUdIb);
</span><del>-        emitModRm_rr(dst, (RegisterID)src);
</del><ins>+        modRm_rr(dst, (RegisterID)src);
</ins><span class="cx">         m_buffer-&gt;putByte(whichWord);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    // Opaque label types
-    
-    class JmpSrc {
-        friend class X86Assembler;
-    public:
-        JmpSrc()
-            : m_offset(-1)
-        {
-        }
-
-    private:
-        JmpSrc(int offset)
-            : m_offset(offset)
-        {
-        }
-
-        int m_offset;
-    };
-    
-    class JmpDst {
-        friend class X86Assembler;
-    public:
-        JmpDst()
-            : m_offset(-1)
-        {
-        }
-
-    private:
-        JmpDst(int offset)
-            : m_offset(offset)
-        {
-        }
-
-        int m_offset;
-    };
-
-    // FIXME: make this point to a global label, linked later.
-    JmpSrc emitCall()
</del><ins>+    JmpSrc call()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_CALL_rel32);
</span><del>-        m_buffer-&gt;putInt(0);
</del><ins>+        m_buffer-&gt;putInt(0); // FIXME: make this point to a global label, linked later.
</ins><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitCall(RegisterID dst)
</del><ins>+    JmpSrc call(RegisterID dst)
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_GROUP5_Ev);
</span><del>-        emitModRm_opr(GROUP5_OP_CALLN, dst);
</del><ins>+        modRm_opr(GROUP5_OP_CALLN, dst);
</ins><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -812,14 +811,14 @@
</span><span class="cx">         return label();
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JmpSrc emitUnlinkedJmp()
</del><ins>+    JmpSrc jmp()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_JMP_rel32);
</span><span class="cx">         m_buffer-&gt;putInt(0);
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJne()
</del><ins>+    JmpSrc jne()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JNE_rel32);
</span><span class="lines">@@ -827,12 +826,12 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJnz()
</del><ins>+    JmpSrc jnz()
</ins><span class="cx">     {
</span><del>-        return emitUnlinkedJne();
</del><ins>+        return jne();
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JmpSrc emitUnlinkedJe()
</del><ins>+    JmpSrc je()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><span class="cx">         m_buffer-&gt;putByteUnchecked(OP_2BYTE_ESCAPE);
</span><span class="lines">@@ -841,7 +840,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJl()
</del><ins>+    JmpSrc jl()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JL_rel32);
</span><span class="lines">@@ -849,7 +848,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJb()
</del><ins>+    JmpSrc jb()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JB_rel32);
</span><span class="lines">@@ -857,7 +856,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJle()
</del><ins>+    JmpSrc jle()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JLE_rel32);
</span><span class="lines">@@ -865,7 +864,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJbe()
</del><ins>+    JmpSrc jbe()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JBE_rel32);
</span><span class="lines">@@ -873,7 +872,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJge()
</del><ins>+    JmpSrc jge()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JGE_rel32);
</span><span class="lines">@@ -881,7 +880,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JmpSrc emitUnlinkedJg()
</del><ins>+    JmpSrc jg()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JG_rel32);
</span><span class="lines">@@ -889,7 +888,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JmpSrc emitUnlinkedJa()
</del><ins>+    JmpSrc ja()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JA_rel32);
</span><span class="lines">@@ -897,7 +896,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJae()
</del><ins>+    JmpSrc jae()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JAE_rel32);
</span><span class="lines">@@ -905,7 +904,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJo()
</del><ins>+    JmpSrc jo()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JO_rel32);
</span><span class="lines">@@ -913,7 +912,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JmpSrc emitUnlinkedJp()
</del><ins>+    JmpSrc jp()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JP_rel32);
</span><span class="lines">@@ -921,7 +920,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc emitUnlinkedJs()
</del><ins>+    JmpSrc js()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(OP_2BYTE_ESCAPE);
</span><span class="cx">         m_buffer-&gt;putByte(OP2_JS_rel32);
</span><span class="lines">@@ -929,7 +928,7 @@
</span><span class="cx">         return JmpSrc(m_buffer-&gt;size());
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void emitPredictionNotTaken()
</del><ins>+    void predictNotTaken()
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(PRE_PREDICT_BRANCH_NOT_TAKEN);
</span><span class="cx">     }
</span><span class="lines">@@ -1003,18 +1002,18 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx"> #if COMPILER(MSVC)
</span><del>-    void emitConvertToFastCall()
</del><ins>+    void convertToFastCall()
</ins><span class="cx">     {
</span><span class="cx">         movl_mr(4, X86::esp, X86::eax);
</span><span class="cx">         movl_mr(8, X86::esp, X86::edx);
</span><span class="cx">         movl_mr(12, X86::esp, X86::ecx);
</span><span class="cx">     }
</span><span class="cx"> #else
</span><del>-    void emitConvertToFastCall() {}
</del><ins>+    void convertToFastCall() {}
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> #if USE(CTI_ARGUMENT)
</span><del>-    void emitRestoreArgumentReference()
</del><ins>+    void restoreArgumentReference()
</ins><span class="cx">     {
</span><span class="cx"> #if USE(FAST_CALL_CTI_ARGUMENT)
</span><span class="cx">         movl_rr(X86::esp, X86::ecx);
</span><span class="lines">@@ -1023,7 +1022,7 @@
</span><span class="cx"> #endif
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitRestoreArgumentReferenceForTrampoline()
</del><ins>+    void restoreArgumentReferenceForTrampoline()
</ins><span class="cx">     {
</span><span class="cx"> #if USE(FAST_CALL_CTI_ARGUMENT)
</span><span class="cx">         movl_rr(X86::esp, X86::ecx);
</span><span class="lines">@@ -1031,29 +1030,29 @@
</span><span class="cx"> #endif
</span><span class="cx">     }
</span><span class="cx"> #else
</span><del>-    void emitRestoreArgumentReference() {}
-    void emitRestoreArgumentReferenceForTrampoline() {}
</del><ins>+    void restoreArgumentReference() {}
+    void restoreArgumentReferenceForTrampoline() {}
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> private:
</span><del>-    void emitModRm_rr(RegisterID reg, RegisterID rm)
</del><ins>+    void modRm_rr(RegisterID reg, RegisterID rm)
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><del>-        emitModRm_rr_Unchecked(reg, rm);
</del><ins>+        modRm_rr_Unchecked(reg, rm);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_rr_Unchecked(RegisterID reg, RegisterID rm)
</del><ins>+    void modRm_rr_Unchecked(RegisterID reg, RegisterID rm)
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByteUnchecked(MODRM(3, reg, rm));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_rm(RegisterID reg, void* addr)
</del><ins>+    void modRm_rm(RegisterID reg, void* addr)
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;putByte(MODRM(0, reg, X86::noBase));
</span><span class="cx">         m_buffer-&gt;putInt((int)addr);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_rm(RegisterID reg, RegisterID base)
</del><ins>+    void modRm_rm(RegisterID reg, RegisterID base)
</ins><span class="cx">     {
</span><span class="cx">         if (base == X86::esp) {
</span><span class="cx">             m_buffer-&gt;putByte(MODRM(0, reg, X86::hasSib));
</span><span class="lines">@@ -1062,7 +1061,7 @@
</span><span class="cx">             m_buffer-&gt;putByte(MODRM(0, reg, base));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_rm_Unchecked(RegisterID reg, RegisterID base, int offset)
</del><ins>+    void modRm_rm_Unchecked(RegisterID reg, RegisterID base, int offset)
</ins><span class="cx">     {
</span><span class="cx">         if (base == X86::esp) {
</span><span class="cx">             if (CAN_SIGN_EXTEND_8_32(offset)) {
</span><span class="lines">@@ -1085,13 +1084,13 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_rm(RegisterID reg, RegisterID base, int offset)
</del><ins>+    void modRm_rm(RegisterID reg, RegisterID base, int offset)
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><del>-        emitModRm_rm_Unchecked(reg, base, offset);
</del><ins>+        modRm_rm_Unchecked(reg, base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale)
</del><ins>+    void modRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale)
</ins><span class="cx">     {
</span><span class="cx">         int shift = 0;
</span><span class="cx">         while (scale &gt;&gt;= 1)
</span><span class="lines">@@ -1101,7 +1100,7 @@
</span><span class="cx">         m_buffer-&gt;putByte(SIB(shift, index, base));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale, int offset)
</del><ins>+    void modRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale, int offset)
</ins><span class="cx">     {
</span><span class="cx">         int shift = 0;
</span><span class="cx">         while (scale &gt;&gt;= 1)
</span><span class="lines">@@ -1118,40 +1117,40 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opr(OpcodeID opcodeID, RegisterID rm)
</del><ins>+    void modRm_opr(OpcodeID opcodeID, RegisterID rm)
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(maxInstructionSize);
</span><del>-        emitModRm_opr_Unchecked(opcodeID, rm);
</del><ins>+        modRm_opr_Unchecked(opcodeID, rm);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opr_Unchecked(OpcodeID opcodeID, RegisterID rm)
</del><ins>+    void modRm_opr_Unchecked(OpcodeID opcodeID, RegisterID rm)
</ins><span class="cx">     {
</span><del>-        emitModRm_rr_Unchecked(static_cast&lt;RegisterID&gt;(opcodeID), rm);
</del><ins>+        modRm_rr_Unchecked(static_cast&lt;RegisterID&gt;(opcodeID), rm);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm(OpcodeID opcodeID, RegisterID base)
</del><ins>+    void modRm_opm(OpcodeID opcodeID, RegisterID base)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), base);
</del><ins>+        modRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), base);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm_Unchecked(OpcodeID opcodeID, RegisterID base, int offset)
</del><ins>+    void modRm_opm_Unchecked(OpcodeID opcodeID, RegisterID base, int offset)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm_Unchecked(static_cast&lt;RegisterID&gt;(opcodeID), base, offset);
</del><ins>+        modRm_rm_Unchecked(static_cast&lt;RegisterID&gt;(opcodeID), base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm(OpcodeID opcodeID, RegisterID base, int offset)
</del><ins>+    void modRm_opm(OpcodeID opcodeID, RegisterID base, int offset)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), base, offset);
</del><ins>+        modRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm(OpcodeID opcodeID, void* addr)
</del><ins>+    void modRm_opm(OpcodeID opcodeID, void* addr)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), addr);
</del><ins>+        modRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), addr);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opmsib(OpcodeID opcodeID, RegisterID base, RegisterID index, int scale, int offset)
</del><ins>+    void modRm_opmsib(OpcodeID opcodeID, RegisterID base, RegisterID index, int scale, int offset)
</ins><span class="cx">     {
</span><del>-        emitModRm_rmsib(static_cast&lt;RegisterID&gt;(opcodeID), base, index, scale, offset);
</del><ins>+        modRm_rmsib(static_cast&lt;RegisterID&gt;(opcodeID), base, index, scale, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     AssemblerBuffer* m_buffer;
</span></span></pre></div>
<a id="trunkJavaScriptCorejitJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/jit/JIT.cpp (38599 => 38600)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/jit/JIT.cpp        2008-11-19 18:28:57 UTC (rev 38599)
+++ trunk/JavaScriptCore/jit/JIT.cpp        2008-11-19 19:16:30 UTC (rev 38600)
</span><span class="lines">@@ -377,7 +377,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE JmpSrc JIT::emitNakedCall(unsigned bytecodeIndex, X86::RegisterID r)
</span><span class="cx"> {
</span><del>-    JmpSrc call = __ emitCall(r);
</del><ins>+    JmpSrc call = __ call(r);
</ins><span class="cx">     m_calls.append(CallRecord(call, bytecodeIndex));
</span><span class="cx"> 
</span><span class="cx">     return call;
</span><span class="lines">@@ -385,14 +385,14 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE  JmpSrc JIT::emitNakedCall(unsigned bytecodeIndex, void* function)
</span><span class="cx"> {
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, reinterpret_cast&lt;CTIHelper_v&gt;(function), bytecodeIndex));
</span><span class="cx">     return call;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE  JmpSrc JIT::emitNakedFastCall(unsigned bytecodeIndex, void* function)
</span><span class="cx"> {
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, reinterpret_cast&lt;CTIHelper_v&gt;(function), bytecodeIndex));
</span><span class="cx">     return call;
</span><span class="cx"> }
</span><span class="lines">@@ -404,9 +404,9 @@
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="cx"> #endif
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><span class="cx"> #if ENABLE(OPCODE_SAMPLING)
</span><span class="cx">     __ movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="lines">@@ -423,9 +423,9 @@
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="cx"> #endif
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><span class="cx"> #if ENABLE(OPCODE_SAMPLING)
</span><span class="cx">     __ movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="lines">@@ -442,9 +442,9 @@
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="cx"> #endif
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><span class="cx"> #if ENABLE(OPCODE_SAMPLING)
</span><span class="cx">     __ movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="lines">@@ -461,9 +461,9 @@
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="cx"> #endif
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><span class="cx"> #if ENABLE(OPCODE_SAMPLING)
</span><span class="cx">     __ movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="lines">@@ -480,9 +480,9 @@
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="cx"> #endif
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><span class="cx"> #if ENABLE(OPCODE_SAMPLING)
</span><span class="cx">     __ movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="lines">@@ -499,9 +499,9 @@
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="cx"> #endif
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><span class="cx"> #if ENABLE(OPCODE_SAMPLING)
</span><span class="cx">     __ movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="lines">@@ -518,9 +518,9 @@
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="cx"> #endif
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc call = __ emitCall();
</del><ins>+    JmpSrc call = __ call();
</ins><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><span class="cx"> #if ENABLE(OPCODE_SAMPLING)
</span><span class="cx">     __ movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="lines">@@ -533,7 +533,7 @@
</span><span class="cx"> ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg, unsigned bytecodeIndex)
</span><span class="cx"> {
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, reg);
</span><del>-    m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), bytecodeIndex));
</del><ins>+    m_slowCases.append(SlowCaseEntry(__ jne(), bytecodeIndex));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg, unsigned bytecodeIndex, int vReg)
</span><span class="lines">@@ -556,7 +556,7 @@
</span><span class="cx"> ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmNum(RegisterID reg, unsigned bytecodeIndex)
</span><span class="cx"> {
</span><span class="cx">     __ testl_i32r(JSImmediate::TagBitTypeInteger, reg);
</span><del>-    m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), bytecodeIndex));
</del><ins>+    m_slowCases.append(SlowCaseEntry(__ je(), bytecodeIndex));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmNums(RegisterID reg1, RegisterID reg2, unsigned bytecodeIndex)
</span><span class="lines">@@ -580,7 +580,7 @@
</span><span class="cx"> ALWAYS_INLINE JmpSrc JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
</span><span class="cx"> {
</span><span class="cx">     __ subl_i8r(JSImmediate::TagBitTypeInteger, reg);
</span><del>-    return __ emitUnlinkedJe();
</del><ins>+    return __ je();
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID reg)
</span><span class="lines">@@ -601,7 +601,7 @@
</span><span class="cx"> ALWAYS_INLINE void JIT::emitFastArithIntToImmOrSlowCase(RegisterID reg, unsigned bytecodeIndex)
</span><span class="cx"> {
</span><span class="cx">     __ addl_rr(reg, reg);
</span><del>-    m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), bytecodeIndex));
</del><ins>+    m_slowCases.append(SlowCaseEntry(__ jo(), bytecodeIndex));
</ins><span class="cx">     emitFastArithReTagImmediate(reg);
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -614,7 +614,7 @@
</span><span class="cx"> ALWAYS_INLINE JmpSrc JIT::emitArithIntToImmWithJump(RegisterID reg)
</span><span class="cx"> {
</span><span class="cx">     __ addl_rr(reg, reg);
</span><del>-    JmpSrc jmp = __ emitUnlinkedJo();
</del><ins>+    JmpSrc jmp = __ jo();
</ins><span class="cx">     emitFastArithReTagImmediate(reg);
</span><span class="cx">     return jmp;
</span><span class="cx"> }
</span><span class="lines">@@ -729,7 +729,7 @@
</span><span class="cx"> 
</span><span class="cx">         emitCTICall(instruction, i, Interpreter::cti_op_call_eval);
</span><span class="cx">         __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
</span><del>-        wasEval = __ emitUnlinkedJne();
</del><ins>+        wasEval = __ jne();
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // This plants a check for a cached JSFunction value, so we can plant a fast link to the callee.
</span><span class="lines">@@ -737,7 +737,7 @@
</span><span class="cx">     emitGetVirtualRegister(callee, X86::ecx, i);
</span><span class="cx">     __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::ecx);
</span><span class="cx">     JmpDst addressOfLinkedFunctionCheck = __ label();
</span><del>-    m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+    m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">     ASSERT(X86Assembler::getDifferenceBetweenLabels(addressOfLinkedFunctionCheck, __ label()) == repatchOffsetOpCallCall);
</span><span class="cx">     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
</span><span class="cx"> 
</span><span class="lines">@@ -790,9 +790,9 @@
</span><span class="cx">     emitGetVirtualRegisters(src1, X86::eax, src2, X86::edx, i);
</span><span class="cx"> 
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc firstNotImmediate = __ emitUnlinkedJe();
</del><ins>+    JmpSrc firstNotImmediate = __ je();
</ins><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::edx);
</span><del>-    JmpSrc secondNotImmediate = __ emitUnlinkedJe();
</del><ins>+    JmpSrc secondNotImmediate = __ je();
</ins><span class="cx"> 
</span><span class="cx">     __ cmpl_rr(X86::edx, X86::eax);
</span><span class="cx">     if (negated)
</span><span class="lines">@@ -802,7 +802,7 @@
</span><span class="cx">     __ movzbl_rr(X86::eax, X86::eax);
</span><span class="cx">     emitTagAsBoolImmediate(X86::eax);
</span><span class="cx">             
</span><del>-    JmpSrc bothWereImmediates = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc bothWereImmediates = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     __ link(firstNotImmediate, __ label());
</span><span class="cx"> 
</span><span class="lines">@@ -815,16 +815,16 @@
</span><span class="cx">     __ movzbl_rr(X86::edx, X86::edx); // edx is now 1 if edx was the 0 immediate
</span><span class="cx">     __ orl_rr(X86::ecx, X86::edx);
</span><span class="cx"> 
</span><del>-    m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
</del><ins>+    m_slowCases.append(SlowCaseEntry(__ jnz(), i));
</ins><span class="cx"> 
</span><span class="cx">     __ movl_i32r(asInteger(jsBoolean(negated)), X86::eax);
</span><span class="cx"> 
</span><del>-    JmpSrc firstWasNotImmediate = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc firstWasNotImmediate = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     __ link(secondNotImmediate, __ label());
</span><span class="cx">     // check that eax is not the zero immediate (we know it must be immediate)
</span><span class="cx">     __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
</span><del>-    m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), i));
</del><ins>+    m_slowCases.append(SlowCaseEntry(__ je(), i));
</ins><span class="cx"> 
</span><span class="cx">     __ movl_i32r(asInteger(jsBoolean(negated)), X86::eax);
</span><span class="cx"> 
</span><span class="lines">@@ -837,7 +837,7 @@
</span><span class="cx"> void JIT::emitSlowScriptCheck(Instruction* vPC, unsigned bytecodeIndex)
</span><span class="cx"> {
</span><span class="cx">     __ subl_i8r(1, X86::esi);
</span><del>-    JmpSrc skipTimeout = __ emitUnlinkedJne();
</del><ins>+    JmpSrc skipTimeout = __ jne();
</ins><span class="cx">     emitCTICall(vPC, bytecodeIndex, Interpreter::cti_timeout_check);
</span><span class="cx"> 
</span><span class="cx">     emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
</span><span class="lines">@@ -866,7 +866,7 @@
</span><span class="cx">     __ cvtsi2sd_rr(tempReg1, tempXmm);
</span><span class="cx">     // Compare &amp; branch if immediate. 
</span><span class="cx">     __ ucomis_rr(tempXmm, xmmSource);
</span><del>-    JmpSrc resultIsImm = __ emitUnlinkedJe();
</del><ins>+    JmpSrc resultIsImm = __ je();
</ins><span class="cx">     JmpDst resultLookedLikeImmButActuallyIsnt = __ label();
</span><span class="cx">     
</span><span class="cx">     // Store the result to the JSNumberCell and jump.
</span><span class="lines">@@ -874,15 +874,15 @@
</span><span class="cx">     if (jsNumberCell != X86::eax)
</span><span class="cx">         __ movl_rr(jsNumberCell, X86::eax);
</span><span class="cx">     emitPutVirtualRegister(dst);
</span><del>-    *wroteJSNumberCell = __ emitUnlinkedJmp();
</del><ins>+    *wroteJSNumberCell = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     __ link(resultIsImm, __ label());
</span><span class="cx">     // value == (double)(JSImmediate)value... or at least, it looks that way...
</span><span class="cx">     // ucomi will report that (0 == -0), and will report true if either input in NaN (result is unordered).
</span><del>-    __ link(__ emitUnlinkedJp(), resultLookedLikeImmButActuallyIsnt); // Actually was a NaN
</del><ins>+    __ link(__ jp(), resultLookedLikeImmButActuallyIsnt); // Actually was a NaN
</ins><span class="cx">     __ pextrw_irr(3, xmmSource, tempReg2);
</span><span class="cx">     __ cmpl_i32r(0x8000, tempReg2);
</span><del>-    __ link(__ emitUnlinkedJe(), resultLookedLikeImmButActuallyIsnt); // Actually was -0
</del><ins>+    __ link(__ je(), resultLookedLikeImmButActuallyIsnt); // Actually was -0
</ins><span class="cx">     // Yes it really really really is representable as a JSImmediate.
</span><span class="cx">     emitFastArithIntToImmNoCheck(tempReg1);
</span><span class="cx">     if (tempReg1 != X86::eax)
</span><span class="lines">@@ -905,26 +905,26 @@
</span><span class="cx"> 
</span><span class="cx">         // Check op2 is a number
</span><span class="cx">         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::edx);
</span><del>-        JmpSrc op2imm = __ emitUnlinkedJne();
</del><ins>+        JmpSrc op2imm = __ jne();
</ins><span class="cx">         if (!types.second().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
</span><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // (1) In this case src2 is a reusable number cell.
</span><span class="cx">         //     Slow case if src1 is not a number type.
</span><span class="cx">         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-        JmpSrc op1imm = __ emitUnlinkedJne();
</del><ins>+        JmpSrc op1imm = __ jne();
</ins><span class="cx">         if (!types.first().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
</span><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // (1a) if we get here, src1 is also a number cell
</span><span class="cx">         __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</span><del>-        JmpSrc loadedDouble = __ emitUnlinkedJmp();
</del><ins>+        JmpSrc loadedDouble = __ jmp();
</ins><span class="cx">         // (1b) if we get here, src1 is an immediate
</span><span class="cx">         __ link(op1imm, __ label());
</span><span class="cx">         emitFastArithImmToInt(X86::eax);
</span><span class="lines">@@ -941,7 +941,7 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::edx, dst, &amp;wasJSNumberCell2, X86::xmm1, X86::ecx, X86::eax);
</span><del>-        wasJSNumberCell2b = __ emitUnlinkedJmp();
</del><ins>+        wasJSNumberCell2b = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">         // (2) This handles cases where src2 is an immediate number.
</span><span class="cx">         //     Two slow cases - either src1 isn't an immediate, or the subtract overflows.
</span><span class="lines">@@ -952,26 +952,26 @@
</span><span class="cx"> 
</span><span class="cx">         // Check op1 is a number
</span><span class="cx">         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-        JmpSrc op1imm = __ emitUnlinkedJne();
</del><ins>+        JmpSrc op1imm = __ jne();
</ins><span class="cx">         if (!types.first().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
</span><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // (1) In this case src1 is a reusable number cell.
</span><span class="cx">         //     Slow case if src2 is not a number type.
</span><span class="cx">         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::edx);
</span><del>-        JmpSrc op2imm = __ emitUnlinkedJne();
</del><ins>+        JmpSrc op2imm = __ jne();
</ins><span class="cx">         if (!types.second().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
</span><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // (1a) if we get here, src2 is also a number cell
</span><span class="cx">         __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm1);
</span><del>-        JmpSrc loadedDouble = __ emitUnlinkedJmp();
</del><ins>+        JmpSrc loadedDouble = __ jmp();
</ins><span class="cx">         // (1b) if we get here, src2 is an immediate
</span><span class="cx">         __ link(op2imm, __ label());
</span><span class="cx">         emitFastArithImmToInt(X86::edx);
</span><span class="lines">@@ -991,7 +991,7 @@
</span><span class="cx">         emitPutVirtualRegister(dst);
</span><span class="cx"> 
</span><span class="cx">         putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::eax, dst, &amp;wasJSNumberCell1, X86::xmm1, X86::ecx, X86::edx);
</span><del>-        wasJSNumberCell1b = __ emitUnlinkedJmp();
</del><ins>+        wasJSNumberCell1b = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">         // (2) This handles cases where src1 is an immediate number.
</span><span class="cx">         //     Two slow cases - either src2 isn't an immediate, or the subtract overflows.
</span><span class="lines">@@ -1003,10 +1003,10 @@
</span><span class="cx">     if (opcodeID == op_add) {
</span><span class="cx">         emitFastArithDeTagImmediate(X86::eax);
</span><span class="cx">         __ addl_rr(X86::edx, X86::eax);
</span><del>-        m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+        m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">     } else  if (opcodeID == op_sub) {
</span><span class="cx">         __ subl_rr(X86::edx, X86::eax);
</span><del>-        m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+        m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">         emitFastArithReTagImmediate(X86::eax);
</span><span class="cx">     } else {
</span><span class="cx">         ASSERT(opcodeID == op_mul);
</span><span class="lines">@@ -1014,17 +1014,17 @@
</span><span class="cx">         emitFastArithImmToInt(X86::edx);
</span><span class="cx">         JmpSrc op1Zero = emitFastArithDeTagImmediateJumpIfZero(X86::eax);
</span><span class="cx">         __ testl_rr(X86::edx, X86::edx);
</span><del>-        JmpSrc op2NonZero = __ emitUnlinkedJne();
</del><ins>+        JmpSrc op2NonZero = __ jne();
</ins><span class="cx">         __ link(op1Zero, __ label());
</span><span class="cx">         // if either input is zero, add the two together, and check if the result is &lt; 0.
</span><span class="cx">         // If it is, we have a problem (N &lt; 0), (N * 0) == -0, not representatble as a JSImmediate. 
</span><span class="cx">         __ movl_rr(X86::eax, X86::ecx);
</span><span class="cx">         __ addl_rr(X86::edx, X86::ecx);
</span><del>-        m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJs(), i));
</del><ins>+        m_slowCases.append(SlowCaseEntry(__ js(), i));
</ins><span class="cx">         // Skip the above check if neither input is zero
</span><span class="cx">         __ link(op2NonZero, __ label());
</span><span class="cx">         __ imull_rr(X86::edx, X86::eax);
</span><del>-        m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+        m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">         emitFastArithReTagImmediate(X86::eax);
</span><span class="cx">     }
</span><span class="cx">     emitPutVirtualRegister(dst);
</span><span class="lines">@@ -1125,13 +1125,13 @@
</span><span class="cx">                 emitGetVirtualRegister(src2, X86::eax, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">                 __ addl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
</span><del>-                m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+                m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">                 emitPutVirtualRegister(dst);
</span><span class="cx">             } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
</span><span class="cx">                 emitGetVirtualRegister(src1, X86::eax, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">                 __ addl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
</span><del>-                m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+                m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">                 emitPutVirtualRegister(dst);
</span><span class="cx">             } else {
</span><span class="cx">                 OperandTypes types = OperandTypes::fromInt(instruction[i + 4].u.operand);
</span><span class="lines">@@ -1159,7 +1159,7 @@
</span><span class="cx">         }
</span><span class="cx">         case op_jmp: {
</span><span class="cx">             unsigned target = instruction[i + 1].u.operand;
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 1 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ jmp(), i + 1 + target));
</ins><span class="cx">             i += 2;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="lines">@@ -1168,7 +1168,7 @@
</span><span class="cx">             emitGetVirtualRegister(srcDst, X86::eax, i);
</span><span class="cx">             emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">             __ addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">             emitPutVirtualRegister(srcDst);
</span><span class="cx">             i += 2;
</span><span class="cx">             break;
</span><span class="lines">@@ -1177,7 +1177,7 @@
</span><span class="cx">             emitSlowScriptCheck(instruction + i, i);
</span><span class="cx"> 
</span><span class="cx">             unsigned target = instruction[i + 1].u.operand;
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 1 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ jmp(), i + 1 + target));
</ins><span class="cx">             i += 2;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="lines">@@ -1190,13 +1190,13 @@
</span><span class="cx">                 emitGetVirtualRegister(instruction[i + 1].u.operand, X86::edx, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">                 __ cmpl_i32r(asInteger(src2imm), X86::edx);
</span><del>-                m_jmpTable.append(JmpTable(__ emitUnlinkedJl(), i + 3 + target));
</del><ins>+                m_jmpTable.append(JmpTable(__ jl(), i + 3 + target));
</ins><span class="cx">             } else {
</span><span class="cx">                 emitGetVirtualRegisters(instruction[i + 1].u.operand, X86::eax, instruction[i + 2].u.operand, X86::edx, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">                 __ cmpl_rr(X86::edx, X86::eax);
</span><del>-                m_jmpTable.append(JmpTable(__ emitUnlinkedJl(), i + 3 + target));
</del><ins>+                m_jmpTable.append(JmpTable(__ jl(), i + 3 + target));
</ins><span class="cx">             }
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -1210,13 +1210,13 @@
</span><span class="cx">                 emitGetVirtualRegister(instruction[i + 1].u.operand, X86::edx, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">                 __ cmpl_i32r(asInteger(src2imm), X86::edx);
</span><del>-                m_jmpTable.append(JmpTable(__ emitUnlinkedJle(), i + 3 + target));
</del><ins>+                m_jmpTable.append(JmpTable(__ jle(), i + 3 + target));
</ins><span class="cx">             } else {
</span><span class="cx">                 emitGetVirtualRegisters(instruction[i + 1].u.operand, X86::eax, instruction[i + 2].u.operand, X86::edx, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">                 __ cmpl_rr(X86::edx, X86::eax);
</span><del>-                m_jmpTable.append(JmpTable(__ emitUnlinkedJle(), i + 3 + target));
</del><ins>+                m_jmpTable.append(JmpTable(__ jle(), i + 3 + target));
</ins><span class="cx">             }
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -1247,7 +1247,7 @@
</span><span class="cx">             // It is important that the following instruction plants a 32bit immediate, in order that it can be patched over.
</span><span class="cx">             __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdStructure);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             // Plant a load from a bogus ofset in the object's property map; we will patch this later, if it is to be used.
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</span><span class="lines">@@ -1276,7 +1276,7 @@
</span><span class="cx"> 
</span><span class="cx">             __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdStructure);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdBranchToSlowCase);
</span><span class="cx"> 
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</span><span class="lines">@@ -1297,7 +1297,7 @@
</span><span class="cx">             __ orl_rr(X86::edx, X86::ecx);
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::ecx);
</span><span class="cx"> 
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jnz(), i));
</ins><span class="cx"> 
</span><span class="cx">             // check that all are object type - this is a bit of a bithack to avoid excess branching;
</span><span class="cx">             // we check that the sum of the three type codes from Structures is exactly 3 * ObjectType,
</span><span class="lines">@@ -1311,14 +1311,14 @@
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
</span><span class="cx">             __ cmpl_rm(X86::ecx, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::edx);
</span><span class="cx"> 
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             // check that baseVal's flags include ImplementsHasInstance but not OverridesHasInstance
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::edx, X86::ecx);
</span><span class="cx">             __ andl_i32r(ImplementsHasInstance | OverridesHasInstance, X86::ecx);
</span><span class="cx">             __ cmpl_i32r(ImplementsHasInstance, X86::ecx);
</span><span class="cx"> 
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 2].u.operand, X86::ecx, i); // reload value
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 4].u.operand, X86::edx, i); // reload proto
</span><span class="lines">@@ -1333,10 +1333,10 @@
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</span><span class="cx">             
</span><span class="cx">             __ cmpl_rr(X86::ecx, X86::edx);
</span><del>-            JmpSrc exit = __ emitUnlinkedJe();
</del><ins>+            JmpSrc exit = __ je();
</ins><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(asInteger(jsNull()), X86::ecx);
</span><del>-            JmpSrc goToLoop = __ emitUnlinkedJne();
</del><ins>+            JmpSrc goToLoop = __ jne();
</ins><span class="cx">             __ link(goToLoop, loop);
</span><span class="cx"> 
</span><span class="cx">             __ movl_i32r(asInteger(jsBoolean(false)), X86::eax);
</span><span class="lines">@@ -1371,7 +1371,7 @@
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">                 emitFastArithDeTagImmediate(X86::eax);
</span><span class="cx">                 __ imull_i32r(X86::eax, value, X86::eax);
</span><del>-                m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+                m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">                 emitFastArithReTagImmediate(X86::eax);
</span><span class="cx">                 emitPutVirtualRegister(dst);
</span><span class="cx">             } else if (src2Value &amp;&amp; ((value = JSImmediate::intValue(src2Value)) &gt; 0)) {
</span><span class="lines">@@ -1379,7 +1379,7 @@
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">                 emitFastArithDeTagImmediate(X86::eax);
</span><span class="cx">                 __ imull_i32r(X86::eax, value, X86::eax);
</span><del>-                m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+                m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">                 emitFastArithReTagImmediate(X86::eax);
</span><span class="cx">                 emitPutVirtualRegister(dst);
</span><span class="cx">             } else
</span><span class="lines">@@ -1498,10 +1498,10 @@
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
</span><span class="cx"> 
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-            JmpSrc isImmediate = __ emitUnlinkedJne();
</del><ins>+            JmpSrc isImmediate = __ jne();
</ins><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</span><span class="cx">             __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
</span><del>-            JmpSrc isObject = __ emitUnlinkedJe();
</del><ins>+            JmpSrc isObject = __ je();
</ins><span class="cx"> 
</span><span class="cx">             __ link(isImmediate, __ label());
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 2].u.operand, X86::eax, i);
</span><span class="lines">@@ -1516,14 +1516,14 @@
</span><span class="cx">             emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">             emitFastArithImmToInt(X86::edx);
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(m_interpreter-&gt;m_jsArrayVptr), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
</span><span class="cx">             __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jbe(), i));
</ins><span class="cx"> 
</span><span class="cx">             // Get the value from the vector
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::eax);
</span><span class="lines">@@ -1550,22 +1550,22 @@
</span><span class="cx">             emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">             emitFastArithImmToInt(X86::edx);
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(m_interpreter-&gt;m_jsArrayVptr), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
</span><span class="cx">             __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
</span><del>-            JmpSrc inFastVector = __ emitUnlinkedJa();
</del><ins>+            JmpSrc inFastVector = __ ja();
</ins><span class="cx">             // No; oh well, check if the access if within the vector - if so, we may still be okay.
</span><span class="cx">             __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jbe(), i));
</ins><span class="cx"> 
</span><span class="cx">             // 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.
</span><span class="cx">             // 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. 
</span><span class="cx">             __ cmpl_i8m(0, FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ je(), i));
</ins><span class="cx"> 
</span><span class="cx">             // All good - put the value into the array.
</span><span class="cx">             __ link(inFastVector, __ label());
</span><span class="lines">@@ -1582,14 +1582,14 @@
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
</span><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
</span><del>-            JmpSrc isZero = __ emitUnlinkedJe();
</del><ins>+            JmpSrc isZero = __ je();
</ins><span class="cx">             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJne(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ jne(), i + 2 + target));
</ins><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::trueImmediate()), X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
</ins><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::falseImmediate()), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             __ link(isZero, __ label());
</span><span class="cx">             i += 3;
</span><span class="lines">@@ -1608,15 +1608,15 @@
</span><span class="cx">             emitGetVirtualRegister(srcVReg, X86::eax, i);
</span><span class="cx"> 
</span><span class="cx">             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-            JmpSrc notImmediate = __ emitUnlinkedJe();
</del><ins>+            JmpSrc notImmediate = __ je();
</ins><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-            JmpSrc zeroImmediate = __ emitUnlinkedJe();
</del><ins>+            JmpSrc zeroImmediate = __ je();
</ins><span class="cx">             emitFastArithImmToInt(X86::eax);
</span><span class="cx">             __ negl_r(X86::eax); // This can't overflow as we only have a 31bit int at this point
</span><span class="cx">             JmpSrc overflow = emitArithIntToImmWithJump(X86::eax);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><del>-            JmpSrc immediateNegateSuccess = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc immediateNegateSuccess = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             if (!isSSE2Present()) {
</span><span class="cx">                 __ link(zeroImmediate, __ label());
</span><span class="lines">@@ -1635,7 +1635,7 @@
</span><span class="cx">                     emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
</span><span class="cx">                     Structure* numberStructure = m_globalData-&gt;numberStructure.get();
</span><span class="cx">                     __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-                    m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+                    m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">                 }
</span><span class="cx">                 __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</span><span class="cx">                 // We need 3 copies of the sign bit mask so we can assure alignment and pad for the 128bit load
</span><span class="lines">@@ -1673,14 +1673,14 @@
</span><span class="cx">             __ movl_i32r(globalObject, X86::eax);
</span><span class="cx">             __ movl_mr(structureAddress, X86::edx);
</span><span class="cx">             __ cmpl_rm(X86::edx, FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-            JmpSrc noMatch = __ emitUnlinkedJne(); // Structures don't match
</del><ins>+            JmpSrc noMatch = __ jne(); // Structures don't match
</ins><span class="cx"> 
</span><span class="cx">             // Load cached property
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSGlobalObject, m_propertyStorage), X86::eax, X86::eax);
</span><span class="cx">             __ movl_mr(offsetAddr, X86::edx);
</span><span class="cx">             __ movl_mr(0, X86::eax, X86::edx, sizeof(JSValue*), X86::eax);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><del>-            JmpSrc end = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc end = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             // Slow case
</span><span class="cx">             __ link(noMatch, __ label());
</span><span class="lines">@@ -1699,7 +1699,7 @@
</span><span class="cx">             emitGetVirtualRegister(srcDst, X86::eax, i);
</span><span class="cx">             emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">             __ subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">             emitPutVirtualRegister(srcDst);
</span><span class="cx">             i += 2;
</span><span class="cx">             break;
</span><span class="lines">@@ -1711,13 +1711,13 @@
</span><span class="cx">                 emitGetVirtualRegister(instruction[i + 1].u.operand, X86::edx, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">                 __ cmpl_i32r(asInteger(src2imm), X86::edx);
</span><del>-                m_jmpTable.append(JmpTable(__ emitUnlinkedJge(), i + 3 + target));
</del><ins>+                m_jmpTable.append(JmpTable(__ jge(), i + 3 + target));
</ins><span class="cx">             } else {
</span><span class="cx">                 emitGetVirtualRegisters(instruction[i + 1].u.operand, X86::eax, instruction[i + 2].u.operand, X86::edx, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">                 emitJumpSlowCaseIfNotImmNum(X86::edx, i);
</span><span class="cx">                 __ cmpl_rr(X86::edx, X86::eax);
</span><del>-                m_jmpTable.append(JmpTable(__ emitUnlinkedJge(), i + 3 + target));
</del><ins>+                m_jmpTable.append(JmpTable(__ jge(), i + 3 + target));
</ins><span class="cx">             }
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -1726,7 +1726,7 @@
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 2].u.operand, X86::eax, i);
</span><span class="cx">             __ xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
</span><span class="cx">             __ testl_i32r(JSImmediate::FullTagTypeMask, X86::eax); // i8?
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">             __ xorl_i8r((JSImmediate::FullTagTypeBool | JSImmediate::ExtendedPayloadBitBoolValue), X86::eax);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><span class="cx">             i += 3;
</span><span class="lines">@@ -1737,14 +1737,14 @@
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
</span><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
</ins><span class="cx">             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-            JmpSrc isNonZero = __ emitUnlinkedJne();
</del><ins>+            JmpSrc isNonZero = __ jne();
</ins><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::falseImmediate()), X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
</ins><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::trueImmediate()), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             __ link(isNonZero, __ label());
</span><span class="cx">             i += 3;
</span><span class="lines">@@ -1756,13 +1756,13 @@
</span><span class="cx"> 
</span><span class="cx">             emitGetVirtualRegister(src, X86::eax, i);
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-            JmpSrc isImmediate = __ emitUnlinkedJnz();
</del><ins>+            JmpSrc isImmediate = __ jnz();
</ins><span class="cx"> 
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</span><span class="cx">             __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</span><span class="cx">             __ setnz_r(X86::eax);
</span><span class="cx"> 
</span><del>-            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc wasNotImmediate = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             __ link(isImmediate, __ label());
</span><span class="cx"> 
</span><span class="lines">@@ -1775,7 +1775,7 @@
</span><span class="cx"> 
</span><span class="cx">             __ movzbl_rr(X86::eax, X86::eax);
</span><span class="cx">             __ cmpl_i32r(0, X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJnz(), i + 2 + target));            
</del><ins>+            m_jmpTable.append(JmpTable(__ jnz(), i + 2 + target));            
</ins><span class="cx"> 
</span><span class="cx">             i += 3;
</span><span class="cx">             break;
</span><span class="lines">@@ -1786,13 +1786,13 @@
</span><span class="cx"> 
</span><span class="cx">             emitGetVirtualRegister(src, X86::eax, i);
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-            JmpSrc isImmediate = __ emitUnlinkedJnz();
</del><ins>+            JmpSrc isImmediate = __ jnz();
</ins><span class="cx"> 
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</span><span class="cx">             __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</span><span class="cx">             __ setz_r(X86::eax);
</span><span class="cx"> 
</span><del>-            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc wasNotImmediate = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             __ link(isImmediate, __ label());
</span><span class="cx"> 
</span><span class="lines">@@ -1805,7 +1805,7 @@
</span><span class="cx"> 
</span><span class="cx">             __ movzbl_rr(X86::eax, X86::eax);
</span><span class="cx">             __ cmpl_i32r(0, X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJnz(), i + 2 + target));            
</del><ins>+            m_jmpTable.append(JmpTable(__ jnz(), i + 2 + target));            
</ins><span class="cx"> 
</span><span class="cx">             i += 3;
</span><span class="cx">             break;
</span><span class="lines">@@ -1816,7 +1816,7 @@
</span><span class="cx">             __ movl_rr(X86::eax, X86::edx);
</span><span class="cx">             emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">             __ addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::edx);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">             emitPutVirtualRegister(srcDst, X86::edx);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><span class="cx">             i += 3;
</span><span class="lines">@@ -1834,7 +1834,7 @@
</span><span class="cx">             int target = instruction[i + 2].u.operand;
</span><span class="cx">             __ movl_i32m(0, sizeof(Register) * retAddrDst, X86::edi);
</span><span class="cx">             JmpDst addrPosition = __ label();
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ jmp(), i + 2 + target));
</ins><span class="cx">             JmpDst sretTarget = __ label();
</span><span class="cx">             m_jsrSites.append(JSRInfo(addrPosition, sretTarget));
</span><span class="cx">             i += 3;
</span><span class="lines">@@ -1946,14 +1946,14 @@
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
</span><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
</span><del>-            JmpSrc isZero = __ emitUnlinkedJe();
</del><ins>+            JmpSrc isZero = __ je();
</ins><span class="cx">             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJne(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ jne(), i + 2 + target));
</ins><span class="cx"> 
</span><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::trueImmediate()), X86::eax);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ je(), i + 2 + target));
</ins><span class="cx">             __ cmpl_i32r(asInteger(JSImmediate::falseImmediate()), X86::eax);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx"> 
</span><span class="cx">             __ link(isZero, __ label());
</span><span class="cx">             i += 3;
</span><span class="lines">@@ -1980,7 +1980,7 @@
</span><span class="cx">             __ movl_rr(X86::eax, X86::edx);
</span><span class="cx">             emitJumpSlowCaseIfNotImmNum(X86::eax, i);
</span><span class="cx">             __ subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::edx);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jo(), i));
</ins><span class="cx">             emitPutVirtualRegister(srcDst, X86::edx);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><span class="cx">             i += 3;
</span><span class="lines">@@ -2035,9 +2035,9 @@
</span><span class="cx">             unsigned target = instruction[i + 3].u.operand;
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_next_pname);
</span><span class="cx">             __ testl_rr(X86::eax, X86::eax);
</span><del>-            JmpSrc endOfIter = __ emitUnlinkedJe();
</del><ins>+            JmpSrc endOfIter = __ je();
</ins><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 3 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ jmp(), i + 3 + target));
</ins><span class="cx">             __ link(endOfIter, __ label());
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -2075,14 +2075,14 @@
</span><span class="cx">             emitGetVirtualRegister(srcVReg, X86::eax, i);
</span><span class="cx">             
</span><span class="cx">             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
</span><del>-            JmpSrc wasImmediate = __ emitUnlinkedJnz();
</del><ins>+            JmpSrc wasImmediate = __ jnz();
</ins><span class="cx"> 
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
</span><span class="cx"> 
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</span><span class="cx">             __ cmpl_i32m(NumberType, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::ecx);
</span><span class="cx">             
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jne(), i));
</ins><span class="cx">             
</span><span class="cx">             __ link(wasImmediate, __ label());
</span><span class="cx"> 
</span><span class="lines">@@ -2118,7 +2118,7 @@
</span><span class="cx">             emitPutCTIArgConstant(count, 0);
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_jmp_scopes);
</span><span class="cx">             unsigned target = instruction[i + 2].u.operand;
</span><del>-            m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 2 + target));
</del><ins>+            m_jmpTable.append(JmpTable(__ jmp(), i + 2 + target));
</ins><span class="cx">             i += 3;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="lines">@@ -2230,13 +2230,13 @@
</span><span class="cx"> 
</span><span class="cx">             emitGetVirtualRegister(src1, X86::eax, i);
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-            JmpSrc isImmediate = __ emitUnlinkedJnz();
</del><ins>+            JmpSrc isImmediate = __ jnz();
</ins><span class="cx"> 
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</span><span class="cx">             __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</span><span class="cx">             __ setnz_r(X86::eax);
</span><span class="cx"> 
</span><del>-            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc wasNotImmediate = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             __ link(isImmediate, __ label());
</span><span class="cx"> 
</span><span class="lines">@@ -2260,13 +2260,13 @@
</span><span class="cx"> 
</span><span class="cx">             emitGetVirtualRegister(src1, X86::eax, i);
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-            JmpSrc isImmediate = __ emitUnlinkedJnz();
</del><ins>+            JmpSrc isImmediate = __ jnz();
</ins><span class="cx"> 
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</span><span class="cx">             __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</span><span class="cx">             __ setz_r(X86::eax);
</span><span class="cx"> 
</span><del>-            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc wasNotImmediate = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             __ link(isImmediate, __ label());
</span><span class="cx"> 
</span><span class="lines">@@ -2320,7 +2320,7 @@
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i);
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::edx);
</span><span class="cx">             __ testl_i32m(NeedsThisConversion, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::edx);
</span><del>-            m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
</del><ins>+            m_slowCases.append(SlowCaseEntry(__ jnz(), i));
</ins><span class="cx"> 
</span><span class="cx">             i += 2;
</span><span class="cx">             break;
</span><span class="lines">@@ -2328,7 +2328,7 @@
</span><span class="cx">         case op_profile_will_call: {
</span><span class="cx">             emitGetCTIParam(CTI_ARGS_profilerReference, X86::eax);
</span><span class="cx">             __ cmpl_i32m(0, X86::eax);
</span><del>-            JmpSrc noProfiler = __ emitUnlinkedJe();
</del><ins>+            JmpSrc noProfiler = __ je();
</ins><span class="cx">             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_profile_will_call);
</span><span class="cx">             __ link(noProfiler, __ label());
</span><span class="lines">@@ -2339,7 +2339,7 @@
</span><span class="cx">         case op_profile_did_call: {
</span><span class="cx">             emitGetCTIParam(CTI_ARGS_profilerReference, X86::eax);
</span><span class="cx">             __ cmpl_i32m(0, X86::eax);
</span><del>-            JmpSrc noProfiler = __ emitUnlinkedJe();
</del><ins>+            JmpSrc noProfiler = __ je();
</ins><span class="cx">             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_profile_did_call);
</span><span class="cx">             __ link(noProfiler, __ label());
</span><span class="lines">@@ -2467,19 +2467,19 @@
</span><span class="cx">             emitPutCTIArg(X86::edx, 4);
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_get_by_val);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><del>-            __ link(__ emitUnlinkedJmp(), m_labels[i + 4]);
</del><ins>+            __ link(__ jmp(), m_labels[i + 4]);
</ins><span class="cx"> 
</span><span class="cx">             // This is slow case that handles accesses to arrays above the fast cut-off.
</span><span class="cx">             // First, check if this is an access to the vector
</span><span class="cx">             __ link((++iter)-&gt;from, __ label());
</span><span class="cx">             __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
</span><del>-            __ link(__ emitUnlinkedJbe(), beginGetByValSlow);
</del><ins>+            __ link(__ jbe(), beginGetByValSlow);
</ins><span class="cx"> 
</span><span class="cx">             // okay, missed the fast region, but it is still in the vector.  Get the value.
</span><span class="cx">             __ movl_mr(FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::ecx);
</span><span class="cx">             // Check whether the value loaded is zero; if so we need to return undefined.
</span><span class="cx">             __ testl_rr(X86::ecx, X86::ecx);
</span><del>-            __ link(__ emitUnlinkedJe(), beginGetByValSlow);
</del><ins>+            __ link(__ je(), beginGetByValSlow);
</ins><span class="cx">             __ movl_rr(X86::ecx, X86::eax);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand, X86::eax);
</span><span class="cx"> 
</span><span class="lines">@@ -2542,7 +2542,7 @@
</span><span class="cx">                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
</span><span class="cx">                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
</span><span class="cx">                 __ testl_rr(X86::eax, X86::eax);
</span><del>-                __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
</del><ins>+                __ link(__ jne(), m_labels[i + 3 + target]);
</ins><span class="cx">             } else {
</span><span class="cx">                 __ link(iter-&gt;from, __ label());
</span><span class="cx">                 __ link((++iter)-&gt;from, __ label());
</span><span class="lines">@@ -2550,7 +2550,7 @@
</span><span class="cx">                 emitPutCTIArg(X86::edx, 4);
</span><span class="cx">                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
</span><span class="cx">                 __ testl_rr(X86::eax, X86::eax);
</span><del>-                __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
</del><ins>+                __ link(__ jne(), m_labels[i + 3 + target]);
</ins><span class="cx">             }
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -2614,7 +2614,7 @@
</span><span class="cx">                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
</span><span class="cx">                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
</span><span class="cx">                 __ testl_rr(X86::eax, X86::eax);
</span><del>-                __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
</del><ins>+                __ link(__ jne(), m_labels[i + 3 + target]);
</ins><span class="cx">             } else {
</span><span class="cx">                 __ link(iter-&gt;from, __ label());
</span><span class="cx">                 __ link((++iter)-&gt;from, __ label());
</span><span class="lines">@@ -2622,7 +2622,7 @@
</span><span class="cx">                 emitPutCTIArg(X86::edx, 4);
</span><span class="cx">                 emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
</span><span class="cx">                 __ testl_rr(X86::eax, X86::eax);
</span><del>-                __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
</del><ins>+                __ link(__ jne(), m_labels[i + 3 + target]);
</ins><span class="cx">             }
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -2651,7 +2651,7 @@
</span><span class="cx">             emitPutCTIArg(X86::edx, 4);
</span><span class="cx">             emitPutCTIArg(X86::ecx, 8);
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_val);
</span><del>-            __ link(__ emitUnlinkedJmp(), m_labels[i + 4]);
</del><ins>+            __ link(__ jmp(), m_labels[i + 4]);
</ins><span class="cx"> 
</span><span class="cx">             // slow cases for immediate int accesses to arrays
</span><span class="cx">             __ link((++iter)-&gt;from, __ label());
</span><span class="lines">@@ -2673,7 +2673,7 @@
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
</span><span class="cx">             __ testl_rr(X86::eax, X86::eax);
</span><span class="cx">             unsigned target = instruction[i + 2].u.operand;
</span><del>-            __ link(__ emitUnlinkedJne(), m_labels[i + 2 + target]);
</del><ins>+            __ link(__ jne(), m_labels[i + 2 + target]);
</ins><span class="cx">             i += 3;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="lines">@@ -2698,7 +2698,7 @@
</span><span class="cx">                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
</span><span class="cx">                 emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
</span><span class="cx">                 __ testl_rr(X86::eax, X86::eax);
</span><del>-                __ link(__ emitUnlinkedJe(), m_labels[i + 3 + target]);
</del><ins>+                __ link(__ je(), m_labels[i + 3 + target]);
</ins><span class="cx">             } else {
</span><span class="cx">                 __ link(iter-&gt;from, __ label());
</span><span class="cx">                 __ link((++iter)-&gt;from, __ label());
</span><span class="lines">@@ -2706,7 +2706,7 @@
</span><span class="cx">                 emitPutCTIArg(X86::edx, 4);
</span><span class="cx">                 emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
</span><span class="cx">                 __ testl_rr(X86::eax, X86::eax);
</span><del>-                __ link(__ emitUnlinkedJe(), m_labels[i + 3 + target]);
</del><ins>+                __ link(__ je(), m_labels[i + 3 + target]);
</ins><span class="cx">             }
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -2726,7 +2726,7 @@
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
</span><span class="cx">             __ testl_rr(X86::eax, X86::eax);
</span><span class="cx">             unsigned target = instruction[i + 2].u.operand;
</span><del>-            __ link(__ emitUnlinkedJe(), m_labels[i + 2 + target]); // inverted!
</del><ins>+            __ link(__ je(), m_labels[i + 2 + target]); // inverted!
</ins><span class="cx">             i += 3;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="lines">@@ -2781,7 +2781,7 @@
</span><span class="cx">             emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
</span><span class="cx">             __ testl_rr(X86::eax, X86::eax);
</span><span class="cx">             unsigned target = instruction[i + 2].u.operand;
</span><del>-            __ link(__ emitUnlinkedJne(), m_labels[i + 2 + target]);
</del><ins>+            __ link(__ jne(), m_labels[i + 2 + target]);
</ins><span class="cx">             i += 3;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="lines">@@ -2908,9 +2908,9 @@
</span><span class="cx"> 
</span><span class="cx">             // Fast check for JS function.
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::ecx);
</span><del>-            JmpSrc callLinkFailNotObject = __ emitUnlinkedJne();
</del><ins>+            JmpSrc callLinkFailNotObject = __ jne();
</ins><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(m_interpreter-&gt;m_jsFunctionVptr), X86::ecx);
</span><del>-            JmpSrc callLinkFailNotJSFunction = __ emitUnlinkedJne();
</del><ins>+            JmpSrc callLinkFailNotJSFunction = __ jne();
</ins><span class="cx"> 
</span><span class="cx">             // First, in the case of a construct, allocate the new object.
</span><span class="cx">             if (opcodeID == op_construct) {
</span><span class="lines">@@ -2928,7 +2928,7 @@
</span><span class="cx">             m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation =
</span><span class="cx">                 emitNakedCall(i, m_interpreter-&gt;m_ctiVirtualCallPreLink);
</span><span class="cx"> 
</span><del>-            JmpSrc storeResultForFirstRun = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc storeResultForFirstRun = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             // This is the address for the cold path *after* the first run (which tries to link the call).
</span><span class="cx">             m_callStructureStubCompilationInfo[callLinkInfoIndex].coldPathOther = __ label();
</span><span class="lines">@@ -2941,9 +2941,9 @@
</span><span class="cx"> 
</span><span class="cx">             // Check for JSFunctions.
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::ecx);
</span><del>-            JmpSrc isNotObject = __ emitUnlinkedJne();
</del><ins>+            JmpSrc isNotObject = __ jne();
</ins><span class="cx">             __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(m_interpreter-&gt;m_jsFunctionVptr), X86::ecx);
</span><del>-            JmpSrc isJSFunction = __ emitUnlinkedJe();
</del><ins>+            JmpSrc isJSFunction = __ je();
</ins><span class="cx"> 
</span><span class="cx">             // This handles host functions
</span><span class="cx">             JmpDst notJSFunctionlabel = __ label();
</span><span class="lines">@@ -2951,7 +2951,7 @@
</span><span class="cx">             __ link(callLinkFailNotObject, notJSFunctionlabel);
</span><span class="cx">             __ link(callLinkFailNotJSFunction, notJSFunctionlabel);
</span><span class="cx">             emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? Interpreter::cti_op_construct_NotJSConstruct : Interpreter::cti_op_call_NotJSFunction));
</span><del>-            JmpSrc wasNotJSFunction = __ emitUnlinkedJmp();
</del><ins>+            JmpSrc wasNotJSFunction = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">             // Next, handle JSFunctions...
</span><span class="cx">             __ link(isJSFunction, __ label());
</span><span class="lines">@@ -3005,7 +3005,7 @@
</span><span class="cx">         ASSERT_WITH_MESSAGE((iter + 1) == m_slowCases.end() || firstTo != (iter + 1)-&gt;to,&quot;Not enough jumps linked in slow case codegen.&quot;);
</span><span class="cx">         ASSERT_WITH_MESSAGE(firstTo == iter-&gt;to, &quot;Too many jumps linked in slow case codegen.&quot;);
</span><span class="cx"> 
</span><del>-        __ link(__ emitUnlinkedJmp(), m_labels[i]);
</del><ins>+        __ link(__ jmp(), m_labels[i]);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     ASSERT(propertyAccessInstructionIndex == m_codeBlock-&gt;propertyAccessInstructions.size());
</span><span class="lines">@@ -3034,7 +3034,7 @@
</span><span class="cx">         emitGetCTIParam(CTI_ARGS_registerFile, X86::eax);
</span><span class="cx">         __ leal_mr(m_codeBlock-&gt;numCalleeRegisters * sizeof(Register), X86::edi, X86::edx);
</span><span class="cx">         __ cmpl_mr(FIELD_OFFSET(RegisterFile, m_end), X86::eax, X86::edx);
</span><del>-        slowRegisterFileCheck = __ emitUnlinkedJg();
</del><ins>+        slowRegisterFileCheck = __ jg();
</ins><span class="cx">         afterRegisterFileCheck = __ label();
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -3045,7 +3045,7 @@
</span><span class="cx">     if (m_codeBlock-&gt;codeType == FunctionCode) {
</span><span class="cx">         __ link(slowRegisterFileCheck, __ label());
</span><span class="cx">         emitCTICall(m_codeBlock-&gt;instructions.begin(), 0, Interpreter::cti_register_file_check);
</span><del>-        JmpSrc backToBody = __ emitUnlinkedJmp();
</del><ins>+        JmpSrc backToBody = __ jmp();
</ins><span class="cx">         __ link(backToBody, afterRegisterFileCheck);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -3115,9 +3115,9 @@
</span><span class="cx"> {
</span><span class="cx">     // Check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc failureCases1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases1 = __ jne();
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-    JmpSrc failureCases2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases2 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Checks out okay! - getDirectOffset
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</span><span class="lines">@@ -3151,19 +3151,19 @@
</span><span class="cx"> 
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc failureCases1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases1 = __ jne();
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-    JmpSrc failureCases2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases2 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Check the prototype object's Structure had not changed.
</span><span class="cx">     Structure** prototypeStructureAddress = &amp;(protoObject-&gt;m_structure);
</span><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(prototypeStructure), static_cast&lt;void*&gt;(prototypeStructureAddress));
</span><del>-    JmpSrc failureCases3 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases3 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Checks out okay! - getDirectOffset
</span><span class="cx">     __ movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::eax);
</span><span class="cx"> 
</span><del>-    JmpSrc success = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc success = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     void* code = __ executableCopy();
</span><span class="cx">     ASSERT(code);
</span><span class="lines">@@ -3194,14 +3194,14 @@
</span><span class="cx"> 
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc failureCases1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases1 = __ jne();
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-    JmpSrc failureCases2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases2 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Check the prototype object's Structure had not changed.
</span><span class="cx">     Structure** prototypeStructureAddress = &amp;(protoObject-&gt;m_structure);
</span><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(prototypeStructure), static_cast&lt;void*&gt;(prototypeStructureAddress));
</span><del>-    JmpSrc failureCases3 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases3 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Checks out okay! - getDirectOffset
</span><span class="cx">     __ movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::eax);
</span><span class="lines">@@ -3229,9 +3229,9 @@
</span><span class="cx"> 
</span><span class="cx">     // Check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    bucketsOfFail.append(__ emitUnlinkedJne());
</del><ins>+    bucketsOfFail.append(__ jne());
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-    bucketsOfFail.append(__ emitUnlinkedJne());
</del><ins>+    bucketsOfFail.append(__ jne());
</ins><span class="cx"> 
</span><span class="cx">     Structure* currStructure = structure;
</span><span class="cx">     RefPtr&lt;Structure&gt;* chainEntries = chain-&gt;head();
</span><span class="lines">@@ -3243,7 +3243,7 @@
</span><span class="cx">         // Check the prototype object's Structure had not changed.
</span><span class="cx">         Structure** prototypeStructureAddress = &amp;(protoObject-&gt;m_structure);
</span><span class="cx">         __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(currStructure), static_cast&lt;void*&gt;(prototypeStructureAddress));
</span><del>-        bucketsOfFail.append(__ emitUnlinkedJne());
</del><ins>+        bucketsOfFail.append(__ jne());
</ins><span class="cx">     }
</span><span class="cx">     ASSERT(protoObject);
</span><span class="cx"> 
</span><span class="lines">@@ -3252,7 +3252,7 @@
</span><span class="cx">     __ movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::eax);
</span><span class="cx">     __ ret();
</span><span class="cx"> 
</span><del>-    bucketsOfFail.append(__ emitUnlinkedJmp());
</del><ins>+    bucketsOfFail.append(__ jmp());
</ins><span class="cx"> 
</span><span class="cx">     void* code = __ executableCopy();
</span><span class="cx">     ASSERT(code);
</span><span class="lines">@@ -3269,9 +3269,9 @@
</span><span class="cx"> {
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc failureCases1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases1 = __ jne();
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-    JmpSrc failureCases2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases2 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // checks out okay! - putDirectOffset
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</span><span class="lines">@@ -3309,35 +3309,35 @@
</span><span class="cx">     Vector&lt;JmpSrc, 16&gt; failureCases;
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    failureCases.append(__ emitUnlinkedJne());
</del><ins>+    failureCases.append(__ jne());
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(oldStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</span><del>-    failureCases.append(__ emitUnlinkedJne());
</del><ins>+    failureCases.append(__ jne());
</ins><span class="cx">     Vector&lt;JmpSrc&gt; successCases;
</span><span class="cx"> 
</span><span class="cx">     //  ecx = baseObject
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</span><span class="cx">     // proto(ecx) = baseObject-&gt;structure()-&gt;prototype()
</span><span class="cx">     __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
</span><del>-    failureCases.append(__ emitUnlinkedJne());
</del><ins>+    failureCases.append(__ jne());
</ins><span class="cx">     __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</span><span class="cx">     
</span><span class="cx">     // ecx = baseObject-&gt;m_structure
</span><span class="cx">     for (RefPtr&lt;Structure&gt;* it = chain-&gt;head(); *it; ++it) {
</span><span class="cx">         // null check the prototype
</span><span class="cx">         __ cmpl_i32r(asInteger(jsNull()), X86::ecx);
</span><del>-        successCases.append(__ emitUnlinkedJe());
</del><ins>+        successCases.append(__ je());
</ins><span class="cx"> 
</span><span class="cx">         // Check the structure id
</span><span class="cx">         __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(it-&gt;get()), FIELD_OFFSET(JSCell, m_structure), X86::ecx);
</span><del>-        failureCases.append(__ emitUnlinkedJne());
</del><ins>+        failureCases.append(__ jne());
</ins><span class="cx">         
</span><span class="cx">         __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
</span><span class="cx">         __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
</span><del>-        failureCases.append(__ emitUnlinkedJne());
</del><ins>+        failureCases.append(__ jne());
</ins><span class="cx">         __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    failureCases.append(__ emitUnlinkedJne());
</del><ins>+    failureCases.append(__ jne());
</ins><span class="cx">     for (unsigned i = 0; i &lt; successCases.size(); ++i)
</span><span class="cx">         __ link(successCases[i], __ label());
</span><span class="cx"> 
</span><span class="lines">@@ -3349,7 +3349,7 @@
</span><span class="cx">         __ pushl_i32(newStructure-&gt;propertyStorageCapacity());
</span><span class="cx">         __ pushl_i32(oldStructure-&gt;propertyStorageCapacity());
</span><span class="cx">         __ pushl_r(X86::eax);
</span><del>-        callTarget = __ emitCall();
</del><ins>+        callTarget = __ call();
</ins><span class="cx">         __ addl_i32r(3 * sizeof(void*), X86::esp);
</span><span class="cx">         __ popl_r(X86::edx);
</span><span class="cx">     }
</span><span class="lines">@@ -3370,8 +3370,8 @@
</span><span class="cx">     if (failureCases.size()) {
</span><span class="cx">         for (unsigned i = 0; i &lt; failureCases.size(); ++i)
</span><span class="cx">             __ link(failureCases[i], __ label());
</span><del>-        __ emitRestoreArgumentReferenceForTrampoline();
-        failureJump = __ emitUnlinkedJmp();
</del><ins>+        __ restoreArgumentReferenceForTrampoline();
+        failureJump = __ jmp();
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void* code = __ executableCopy();
</span><span class="lines">@@ -3419,16 +3419,16 @@
</span><span class="cx">     
</span><span class="cx">     // Check eax is an array
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc array_failureCases1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc array_failureCases1 = __ jne();
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(m_interpreter-&gt;m_jsArrayVptr), X86::eax);
</span><del>-    JmpSrc array_failureCases2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc array_failureCases2 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Checks out okay! - get the length from the storage
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::eax);
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(ArrayStorage, m_length), X86::eax, X86::eax);
</span><span class="cx"> 
</span><span class="cx">     __ addl_rr(X86::eax, X86::eax);
</span><del>-    JmpSrc array_failureCases3 = __ emitUnlinkedJo();
</del><ins>+    JmpSrc array_failureCases3 = __ jo();
</ins><span class="cx">     __ addl_i8r(1, X86::eax);
</span><span class="cx">     
</span><span class="cx">     __ ret();
</span><span class="lines">@@ -3439,16 +3439,16 @@
</span><span class="cx"> 
</span><span class="cx">     // Check eax is a string
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc string_failureCases1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc string_failureCases1 = __ jne();
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(m_interpreter-&gt;m_jsStringVptr), X86::eax);
</span><del>-    JmpSrc string_failureCases2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc string_failureCases2 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Checks out okay! - get the length from the Ustring.
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSString, m_value) + FIELD_OFFSET(UString, m_rep), X86::eax, X86::eax);
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(UString::Rep, len), X86::eax, X86::eax);
</span><span class="cx"> 
</span><span class="cx">     __ addl_rr(X86::eax, X86::eax);
</span><del>-    JmpSrc string_failureCases3 = __ emitUnlinkedJo();
</del><ins>+    JmpSrc string_failureCases3 = __ jo();
</ins><span class="cx">     __ addl_i8r(1, X86::eax);
</span><span class="cx">     
</span><span class="cx">     __ ret();
</span><span class="lines">@@ -3461,11 +3461,11 @@
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</span><span class="cx">     __ testl_rr(X86::eax, X86::eax);
</span><del>-    JmpSrc hasCodeBlock1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc hasCodeBlock1 = __ jne();
</ins><span class="cx">     __ popl_r(X86::ebx);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callJSFunction1 = __ emitCall();
</del><ins>+    JmpSrc callJSFunction1 = __ call();
</ins><span class="cx">     emitGetCTIArg(0, X86::ecx);
</span><span class="cx">     emitGetCTIArg(8, X86::edx);
</span><span class="cx">     __ pushl_r(X86::ebx);
</span><span class="lines">@@ -3473,13 +3473,13 @@
</span><span class="cx"> 
</span><span class="cx">     // Check argCount matches callee arity.
</span><span class="cx">     __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
</span><del>-    JmpSrc arityCheckOkay1 = __ emitUnlinkedJe();
</del><ins>+    JmpSrc arityCheckOkay1 = __ je();
</ins><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><span class="cx">     emitPutCTIArg(X86::eax, 12);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callArityCheck1 = __ emitCall();
</del><ins>+    JmpSrc callArityCheck1 = __ call();
</ins><span class="cx">     __ movl_rr(X86::edx, X86::edi);
</span><span class="cx">     emitGetCTIArg(0, X86::ecx);
</span><span class="cx">     emitGetCTIArg(8, X86::edx);
</span><span class="lines">@@ -3490,9 +3490,9 @@
</span><span class="cx"> 
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callDontLazyLinkCall = __ emitCall();
</del><ins>+    JmpSrc callDontLazyLinkCall = __ call();
</ins><span class="cx">     __ pushl_r(X86::ebx);
</span><span class="cx"> 
</span><span class="cx">     __ jmp_r(X86::eax);
</span><span class="lines">@@ -3503,11 +3503,11 @@
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</span><span class="cx">     __ testl_rr(X86::eax, X86::eax);
</span><del>-    JmpSrc hasCodeBlock2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc hasCodeBlock2 = __ jne();
</ins><span class="cx">     __ popl_r(X86::ebx);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callJSFunction2 = __ emitCall();
</del><ins>+    JmpSrc callJSFunction2 = __ call();
</ins><span class="cx">     emitGetCTIArg(0, X86::ecx);
</span><span class="cx">     emitGetCTIArg(8, X86::edx);
</span><span class="cx">     __ pushl_r(X86::ebx);
</span><span class="lines">@@ -3515,13 +3515,13 @@
</span><span class="cx"> 
</span><span class="cx">     // Check argCount matches callee arity.
</span><span class="cx">     __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
</span><del>-    JmpSrc arityCheckOkay2 = __ emitUnlinkedJe();
</del><ins>+    JmpSrc arityCheckOkay2 = __ je();
</ins><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><span class="cx">     emitPutCTIArg(X86::eax, 12);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callArityCheck2 = __ emitCall();
</del><ins>+    JmpSrc callArityCheck2 = __ call();
</ins><span class="cx">     __ movl_rr(X86::edx, X86::edi);
</span><span class="cx">     emitGetCTIArg(0, X86::ecx);
</span><span class="cx">     emitGetCTIArg(8, X86::edx);
</span><span class="lines">@@ -3532,9 +3532,9 @@
</span><span class="cx"> 
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callLazyLinkCall = __ emitCall();
</del><ins>+    JmpSrc callLazyLinkCall = __ call();
</ins><span class="cx">     __ pushl_r(X86::ebx);
</span><span class="cx"> 
</span><span class="cx">     __ jmp_r(X86::eax);
</span><span class="lines">@@ -3545,11 +3545,11 @@
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</span><span class="cx">     __ testl_rr(X86::eax, X86::eax);
</span><del>-    JmpSrc hasCodeBlock3 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc hasCodeBlock3 = __ jne();
</ins><span class="cx">     __ popl_r(X86::ebx);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callJSFunction3 = __ emitCall();
</del><ins>+    JmpSrc callJSFunction3 = __ call();
</ins><span class="cx">     emitGetCTIArg(0, X86::ecx);
</span><span class="cx">     emitGetCTIArg(8, X86::edx);
</span><span class="cx">     __ pushl_r(X86::ebx);
</span><span class="lines">@@ -3557,13 +3557,13 @@
</span><span class="cx"> 
</span><span class="cx">     // Check argCount matches callee arity.
</span><span class="cx">     __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
</span><del>-    JmpSrc arityCheckOkay3 = __ emitUnlinkedJe();
</del><ins>+    JmpSrc arityCheckOkay3 = __ je();
</ins><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><span class="cx">     emitPutCTIArg(X86::eax, 12);
</span><del>-    __ emitRestoreArgumentReference();
</del><ins>+    __ restoreArgumentReference();
</ins><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><del>-    JmpSrc callArityCheck3 = __ emitCall();
</del><ins>+    JmpSrc callArityCheck3 = __ call();
</ins><span class="cx">     __ movl_rr(X86::edx, X86::edi);
</span><span class="cx">     emitGetCTIArg(0, X86::ecx);
</span><span class="cx">     emitGetCTIArg(8, X86::edx);
</span><span class="lines">@@ -3644,21 +3644,21 @@
</span><span class="cx"> 
</span><span class="cx">     // Check eax is an array
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><del>-    JmpSrc failureCases1 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases1 = __ jne();
</ins><span class="cx">     __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(m_interpreter-&gt;m_jsArrayVptr), X86::eax);
</span><del>-    JmpSrc failureCases2 = __ emitUnlinkedJne();
</del><ins>+    JmpSrc failureCases2 = __ jne();
</ins><span class="cx"> 
</span><span class="cx">     // Checks out okay! - get the length from the storage
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
</span><span class="cx">     __ movl_mr(FIELD_OFFSET(ArrayStorage, m_length), X86::ecx, X86::ecx);
</span><span class="cx"> 
</span><span class="cx">     __ cmpl_i32r(JSImmediate::maxImmediateInt, X86::ecx);
</span><del>-    JmpSrc failureCases3 = __ emitUnlinkedJa();
</del><ins>+    JmpSrc failureCases3 = __ ja();
</ins><span class="cx"> 
</span><span class="cx">     __ addl_rr(X86::ecx, X86::ecx);
</span><span class="cx">     __ addl_i8r(1, X86::ecx);
</span><span class="cx">     __ movl_rr(X86::ecx, X86::eax);
</span><del>-    JmpSrc success = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc success = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     void* code = __ executableCopy();
</span><span class="cx">     ASSERT(code);
</span></span></pre></div>
<a id="trunkJavaScriptCorewrecWRECcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/wrec/WREC.cpp (38599 => 38600)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/wrec/WREC.cpp        2008-11-19 18:28:57 UTC (rev 38599)
+++ trunk/JavaScriptCore/wrec/WREC.cpp        2008-11-19 19:16:30 UTC (rev 38600)
</span><span class="lines">@@ -53,7 +53,7 @@
</span><span class="cx">     X86Assembler assembler(interpreter-&gt;assemblerBuffer());
</span><span class="cx">     Parser parser(pattern, ignoreCase, multiline, assembler);
</span><span class="cx">     
</span><del>-    __ emitConvertToFastCall();
</del><ins>+    __ convertToFastCall();
</ins><span class="cx">     // (0) Setup:
</span><span class="cx">     //     Preserve regs &amp; initialize outputRegister.
</span><span class="cx">     __ pushl_r(Generator::outputRegister);
</span><span class="lines">@@ -70,8 +70,8 @@
</span><span class="cx"> #ifndef NDEBUG
</span><span class="cx">     // ASSERT that the output register is not null.
</span><span class="cx">     __ testl_rr(Generator::outputRegister, Generator::outputRegister);
</span><del>-    X86Assembler::JmpSrc outputRegisterNotNull = __ emitUnlinkedJne();
-    __ emitInt3();
</del><ins>+    X86Assembler::JmpSrc outputRegisterNotNull = __ jne();
+    __ int3();
</ins><span class="cx">     __ link(outputRegisterNotNull, __ label());
</span><span class="cx"> #endif
</span><span class="cx">     
</span><span class="lines">@@ -111,7 +111,7 @@
</span><span class="cx">     __ addl_i8r(1, Generator::currentPositionRegister);
</span><span class="cx">     __ movl_rm(Generator::currentPositionRegister, X86::esp);
</span><span class="cx">     __ cmpl_rr(Generator::lengthRegister, Generator::currentPositionRegister);
</span><del>-    __ link(__ emitUnlinkedJle(), nextLabel);
</del><ins>+    __ link(__ jle(), nextLabel);
</ins><span class="cx"> 
</span><span class="cx">     // No more input characters: return failure.
</span><span class="cx">     __ addl_i8r(4, X86::esp);
</span></span></pre></div>
<a id="trunkJavaScriptCorewrecWRECGeneratorcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/wrec/WRECGenerator.cpp (38599 => 38600)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/wrec/WRECGenerator.cpp        2008-11-19 18:28:57 UTC (rev 38599)
+++ trunk/JavaScriptCore/wrec/WRECGenerator.cpp        2008-11-19 19:16:30 UTC (rev 38600)
</span><span class="lines">@@ -57,7 +57,7 @@
</span><span class="cx"> 
</span><span class="cx">     __ movl_mr((2 * subpatternId) * sizeof(int), outputRegister, currentValueRegister);
</span><span class="cx">     __ cmpl_rm(currentValueRegister, ((2 * subpatternId) + 1) * sizeof(int), outputRegister);
</span><del>-    JmpSrc skipIfEmpty = __ emitUnlinkedJe();
</del><ins>+    JmpSrc skipIfEmpty = __ je();
</ins><span class="cx"> 
</span><span class="cx">     ASSERT(quantifierType == Quantifier::Greedy || quantifierType == Quantifier::NonGreedy);
</span><span class="cx">     if (quantifierType == Quantifier::Greedy)
</span><span class="lines">@@ -77,14 +77,14 @@
</span><span class="cx">     //     init quantifierCountRegister
</span><span class="cx">     __ pushl_r(quantifierCountRegister);
</span><span class="cx">     __ xorl_rr(quantifierCountRegister, quantifierCountRegister);
</span><del>-    JmpSrc gotoStart = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc gotoStart = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     // (4) Failure case
</span><span class="cx"> 
</span><span class="cx">     JmpDst quantifierFailed = __ label();
</span><span class="cx">     // (4.1) Restore original value of quantifierCountRegister from the stack
</span><span class="cx">     __ popl_r(quantifierCountRegister);
</span><del>-    failures.append(__ emitUnlinkedJmp()); 
</del><ins>+    failures.append(__ jmp()); 
</ins><span class="cx"> 
</span><span class="cx">     // (3) We just tried an alternative, and it failed - check we can try more.
</span><span class="cx">     
</span><span class="lines">@@ -94,7 +94,7 @@
</span><span class="cx">     // (3.2) if there is a limit, and we have reached it, game over. 
</span><span class="cx">     if (max != Quantifier::noMaxSpecified) {
</span><span class="cx">         __ cmpl_i32r(max, quantifierCountRegister);
</span><del>-        __ link(__ emitUnlinkedJe(), quantifierFailed);
</del><ins>+        __ link(__ je(), quantifierFailed);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // (1) Do a check for the atom
</span><span class="lines">@@ -116,7 +116,7 @@
</span><span class="cx">         // ... except if min was 1 no need to keep checking!
</span><span class="cx">         if (min != 1) {
</span><span class="cx">             __ cmpl_i32r(min, quantifierCountRegister);
</span><del>-            __ link(__ emitUnlinkedJl(), testQuantifiedAtom);
</del><ins>+            __ link(__ jl(), testQuantifiedAtom);
</ins><span class="cx">         }
</span><span class="cx">     } else
</span><span class="cx">         __ link(gotoStart, __ label());
</span><span class="lines">@@ -161,13 +161,13 @@
</span><span class="cx">         if (max != 1) {
</span><span class="cx">             // if there is a limit, only loop while less than limit, otherwise fall throught to...
</span><span class="cx">             __ cmpl_i32r(max, quantifierCountRegister);
</span><del>-            __ link(__ emitUnlinkedJne(), readMore);
</del><ins>+            __ link(__ jne(), readMore);
</ins><span class="cx">         }
</span><span class="cx">         // ...if there is no min we need jump to the alternative test, if there is we can just fall through to it.
</span><span class="cx">         if (!min)
</span><del>-            newFailures.append(__ emitUnlinkedJmp());
</del><ins>+            newFailures.append(__ jmp());
</ins><span class="cx">     } else
</span><del>-        __ link(__ emitUnlinkedJmp(), readMore);
</del><ins>+        __ link(__ jmp(), readMore);
</ins><span class="cx">     // (1.4) check enough matches to bother trying an alternative...
</span><span class="cx">     if (min) {
</span><span class="cx">         // We will fall through to here if (min &amp;&amp; max), after the max check.
</span><span class="lines">@@ -178,7 +178,7 @@
</span><span class="cx">         newFailures.clear();
</span><span class="cx">         // 
</span><span class="cx">         __ cmpl_i32r(min, quantifierCountRegister);
</span><del>-        newFailures.append(__ emitUnlinkedJae());
</del><ins>+        newFailures.append(__ jae());
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // (4) Failure case
</span><span class="lines">@@ -186,7 +186,7 @@
</span><span class="cx">     JmpDst quantifierFailed = __ label();
</span><span class="cx">     // (4.1) Restore original value of quantifierCountRegister from the stack
</span><span class="cx">     __ popl_r(quantifierCountRegister);
</span><del>-    failures.append(__ emitUnlinkedJmp()); 
</del><ins>+    failures.append(__ jmp()); 
</ins><span class="cx"> 
</span><span class="cx">     // (3) Backtrack
</span><span class="cx"> 
</span><span class="lines">@@ -195,7 +195,7 @@
</span><span class="cx">     __ popl_r(currentPositionRegister);
</span><span class="cx">     // (3.2) check we can retry with fewer matches - backtracking fails if already at the minimum
</span><span class="cx">     __ cmpl_i32r(min, quantifierCountRegister);
</span><del>-    __ link(__ emitUnlinkedJe(), quantifierFailed);
</del><ins>+    __ link(__ je(), quantifierFailed);
</ins><span class="cx">     // (3.3) roll off one match, and retry.
</span><span class="cx">     functor.backtrack(this);
</span><span class="cx">     __ subl_i8r(1, quantifierCountRegister);
</span><span class="lines">@@ -222,7 +222,7 @@
</span><span class="cx"> {
</span><span class="cx">     // check there is more input, read a char.
</span><span class="cx">     __ cmpl_rr(lengthRegister, currentPositionRegister);
</span><del>-    failures.append(__ emitUnlinkedJe());
</del><ins>+    failures.append(__ je());
</ins><span class="cx">     __ movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
</span><span class="cx"> 
</span><span class="cx">     // used for unicode case insensitive
</span><span class="lines">@@ -240,7 +240,7 @@
</span><span class="cx">         } else if ((ch &gt; 0x7f) &amp;&amp; ((lower = Unicode::toLower(ch)) != (upper = Unicode::toUpper(ch)))) {
</span><span class="cx">             // handle unicode case sentitive characters - branch to success on upper
</span><span class="cx">             __ cmpl_i32r(upper, currentValueRegister);
</span><del>-            isUpper = __ emitUnlinkedJe();
</del><ins>+            isUpper = __ je();
</ins><span class="cx">             hasUpper = true;
</span><span class="cx">             ch = lower;
</span><span class="cx">         }
</span><span class="lines">@@ -248,7 +248,7 @@
</span><span class="cx">     
</span><span class="cx">     // checks for ch, or lower case version of ch, if insensitive
</span><span class="cx">     __ cmpl_i32r((unsigned short)ch, currentValueRegister);
</span><del>-    failures.append(__ emitUnlinkedJne());
</del><ins>+    failures.append(__ jne());
</ins><span class="cx"> 
</span><span class="cx">     if (m_parser.ignoreCase() &amp;&amp; hasUpper) {
</span><span class="cx">         // for unicode case insensitive matches, branch here if upper matches.
</span><span class="lines">@@ -272,7 +272,7 @@
</span><span class="cx">         // check if there are any ranges or matches below lo.  If not, just jl to failure -
</span><span class="cx">         // if there is anything else to check, check that first, if it falls through jmp to failure.
</span><span class="cx">         if ((*matchIndex &lt; matchCount) &amp;&amp; (matches[*matchIndex] &lt; lo)) {
</span><del>-            JmpSrc loOrAbove = __ emitUnlinkedJge();
</del><ins>+            JmpSrc loOrAbove = __ jge();
</ins><span class="cx">             
</span><span class="cx">             // generate code for all ranges before this one
</span><span class="cx">             if (which)
</span><span class="lines">@@ -280,27 +280,27 @@
</span><span class="cx">             
</span><span class="cx">             do {
</span><span class="cx">                 __ cmpl_i32r((unsigned short)matches[*matchIndex], currentValueRegister);
</span><del>-                matchDest.append(__ emitUnlinkedJe());
</del><ins>+                matchDest.append(__ je());
</ins><span class="cx">                 ++*matchIndex;
</span><span class="cx">             } while ((*matchIndex &lt; matchCount) &amp;&amp; (matches[*matchIndex] &lt; lo));
</span><del>-            failures.append(__ emitUnlinkedJmp());
</del><ins>+            failures.append(__ jmp());
</ins><span class="cx"> 
</span><span class="cx">             __ link(loOrAbove, __ label());
</span><span class="cx">         } else if (which) {
</span><del>-            JmpSrc loOrAbove = __ emitUnlinkedJge();
</del><ins>+            JmpSrc loOrAbove = __ jge();
</ins><span class="cx"> 
</span><span class="cx">             generateCharacterClassInvertedRange(failures, matchDest, ranges, which, matchIndex, matches, matchCount);
</span><del>-            failures.append(__ emitUnlinkedJmp());
</del><ins>+            failures.append(__ jmp());
</ins><span class="cx"> 
</span><span class="cx">             __ link(loOrAbove, __ label());
</span><span class="cx">         } else
</span><del>-            failures.append(__ emitUnlinkedJl());
</del><ins>+            failures.append(__ jl());
</ins><span class="cx"> 
</span><span class="cx">         while ((*matchIndex &lt; matchCount) &amp;&amp; (matches[*matchIndex] &lt;= hi))
</span><span class="cx">             ++*matchIndex;
</span><span class="cx"> 
</span><span class="cx">         __ cmpl_i32r((unsigned short)hi, currentValueRegister);
</span><del>-        matchDest.append(__ emitUnlinkedJle());
</del><ins>+        matchDest.append(__ jle());
</ins><span class="cx">         // fall through to here, the value is above hi.
</span><span class="cx"> 
</span><span class="cx">         // shuffle along &amp; loop around if there are any more matches to handle.
</span><span class="lines">@@ -315,13 +315,13 @@
</span><span class="cx">     JmpSrc unicodeFail;
</span><span class="cx">     if (charClass.numMatchesUnicode || charClass.numRangesUnicode) {
</span><span class="cx">         __ cmpl_i8r(0x7f, currentValueRegister);
</span><del>-        JmpSrc isAscii = __ emitUnlinkedJle();
</del><ins>+        JmpSrc isAscii = __ jle();
</ins><span class="cx">     
</span><span class="cx">         if (charClass.numMatchesUnicode) {
</span><span class="cx">             for (unsigned i = 0; i &lt; charClass.numMatchesUnicode; ++i) {
</span><span class="cx">                 UChar ch = charClass.matchesUnicode[i];
</span><span class="cx">                 __ cmpl_i32r((unsigned short)ch, currentValueRegister);
</span><del>-                matchDest.append(__ emitUnlinkedJe());
</del><ins>+                matchDest.append(__ je());
</ins><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx">         
</span><span class="lines">@@ -331,14 +331,14 @@
</span><span class="cx">                 UChar hi = charClass.rangesUnicode[i].end;
</span><span class="cx">                 
</span><span class="cx">                 __ cmpl_i32r((unsigned short)lo, currentValueRegister);
</span><del>-                JmpSrc below = __ emitUnlinkedJl();
</del><ins>+                JmpSrc below = __ jl();
</ins><span class="cx">                 __ cmpl_i32r((unsigned short)hi, currentValueRegister);
</span><del>-                matchDest.append(__ emitUnlinkedJle());
</del><ins>+                matchDest.append(__ jle());
</ins><span class="cx">                 __ link(below, __ label());
</span><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        unicodeFail = __ emitUnlinkedJmp();
</del><ins>+        unicodeFail = __ jmp();
</ins><span class="cx">         __ link(isAscii, __ label());
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -348,7 +348,7 @@
</span><span class="cx">         generateCharacterClassInvertedRange(failures, matchDest, charClass.ranges, charClass.numRanges, &amp;matchIndex, charClass.matches, charClass.numMatches);
</span><span class="cx">         while (matchIndex &lt; charClass.numMatches) {
</span><span class="cx">             __ cmpl_i32r((unsigned short)charClass.matches[matchIndex], currentValueRegister);
</span><del>-            matchDest.append(__ emitUnlinkedJe());
</del><ins>+            matchDest.append(__ je());
</ins><span class="cx">             ++matchIndex;
</span><span class="cx">         }
</span><span class="cx">         JmpDst noMatch = __ label();
</span><span class="lines">@@ -370,7 +370,7 @@
</span><span class="cx">                     continue;
</span><span class="cx">             }
</span><span class="cx">             __ cmpl_i32r((unsigned short)ch, currentValueRegister);
</span><del>-            matchDest.append(__ emitUnlinkedJe());
</del><ins>+            matchDest.append(__ je());
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         if (unsigned countAZaz = matchesAZaz.size()) {
</span><span class="lines">@@ -379,7 +379,7 @@
</span><span class="cx">             for (unsigned i = 0; i &lt; countAZaz; ++i) {
</span><span class="cx">                 char ch = matchesAZaz[i];
</span><span class="cx">                 __ cmpl_i32r((unsigned short)ch, currentValueRegister);
</span><del>-                matchDest.append(__ emitUnlinkedJe());
</del><ins>+                matchDest.append(__ je());
</ins><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="lines">@@ -391,7 +391,7 @@
</span><span class="cx"> void Generator::generateCharacterClass(JmpSrcVector&amp; failures, const CharacterClass&amp; charClass, bool invert)
</span><span class="cx"> {
</span><span class="cx">     __ cmpl_rr(lengthRegister, currentPositionRegister);
</span><del>-    failures.append(__ emitUnlinkedJe());
</del><ins>+    failures.append(__ je());
</ins><span class="cx">     __ movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
</span><span class="cx"> 
</span><span class="cx">     if (invert)
</span><span class="lines">@@ -399,7 +399,7 @@
</span><span class="cx">     else {
</span><span class="cx">         JmpSrcVector successes;
</span><span class="cx">         generateCharacterClassInverted(successes, charClass);
</span><del>-        failures.append(__ emitUnlinkedJmp());
</del><ins>+        failures.append(__ jmp());
</ins><span class="cx">         JmpDst here = __ label();
</span><span class="cx">         for (unsigned i = 0; i &lt; successes.size(); ++i)
</span><span class="cx">             __ link(successes[i], here);
</span><span class="lines">@@ -435,7 +435,7 @@
</span><span class="cx">     // (suggestion to fix: make parseDisjunction populate a JmpSrcVector of
</span><span class="cx">     // disjunct successes... this is probably not worth the compile cost in
</span><span class="cx">     // the common case to fix).
</span><del>-    JmpSrc successfulMatch = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc successfulMatch = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     JmpDst originalFailure = __ label();
</span><span class="cx">     for (unsigned i = 0; i &lt; newFailures.size(); ++i)
</span><span class="lines">@@ -451,7 +451,7 @@
</span><span class="cx">         jumpToFail = successfulMatch;
</span><span class="cx">     else {
</span><span class="cx">         // plant a jump so any fail will link off to 'failures',
</span><del>-        jumpToFail = __ emitUnlinkedJmp();
</del><ins>+        jumpToFail = __ jmp();
</ins><span class="cx">         // link successes to jump here
</span><span class="cx">         __ link(successfulMatch, __ label());
</span><span class="cx">     }
</span><span class="lines">@@ -460,7 +460,7 @@
</span><span class="cx"> 
</span><span class="cx"> void Generator::generateParenthesesNonGreedy(JmpSrcVector&amp; failures, JmpDst start, JmpSrc success, JmpSrc fail)
</span><span class="cx"> {
</span><del>-    __ link(__ emitUnlinkedJmp(), start);
</del><ins>+    __ link(__ jmp(), start);
</ins><span class="cx">     __ link(success, __ label());
</span><span class="cx"> 
</span><span class="cx">     failures.append(fail);
</span><span class="lines">@@ -468,7 +468,7 @@
</span><span class="cx"> 
</span><span class="cx"> Generator::JmpSrc Generator::generateParenthesesResetTrampoline(JmpSrcVector&amp; newFailures, unsigned subpatternIdBefore, unsigned subpatternIdAfter)
</span><span class="cx"> {
</span><del>-    JmpSrc skip = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc skip = __ jmp();
</ins><span class="cx"> 
</span><span class="cx">     JmpDst subPatternResetTrampoline = __ label();
</span><span class="cx">     for (unsigned i = 0; i &lt; newFailures.size(); ++i)
</span><span class="lines">@@ -479,7 +479,7 @@
</span><span class="cx">         __ movl_i32m(-1, (2 * i + 1) * sizeof(int), outputRegister);
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JmpSrc newFailJump = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc newFailJump = __ jmp();
</ins><span class="cx">     __ link(skip, __ label());
</span><span class="cx">     
</span><span class="cx">     return newFailJump;
</span><span class="lines">@@ -492,13 +492,13 @@
</span><span class="cx"> 
</span><span class="cx">         // begin of input == success
</span><span class="cx">         __ cmpl_i8r(0, currentPositionRegister);
</span><del>-        previousIsNewline.append(__ emitUnlinkedJe());
</del><ins>+        previousIsNewline.append(__ je());
</ins><span class="cx"> 
</span><span class="cx">         // now check prev char against newline characters.
</span><span class="cx">         __ movzwl_mr(-2, inputRegister, currentPositionRegister, 2, currentValueRegister);
</span><span class="cx">         generateCharacterClassInverted(previousIsNewline, CharacterClass::newline());
</span><span class="cx"> 
</span><del>-        failures.append(__ emitUnlinkedJmp());
</del><ins>+        failures.append(__ jmp());
</ins><span class="cx"> 
</span><span class="cx">         JmpDst success = __ label();
</span><span class="cx">         for (unsigned i = 0; i &lt; previousIsNewline.size(); ++i)
</span><span class="lines">@@ -506,7 +506,7 @@
</span><span class="cx">         previousIsNewline.clear();
</span><span class="cx">     } else {
</span><span class="cx">         __ cmpl_i8r(0, currentPositionRegister);
</span><del>-        failures.append(__ emitUnlinkedJne());
</del><ins>+        failures.append(__ jne());
</ins><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -517,13 +517,13 @@
</span><span class="cx"> 
</span><span class="cx">         // end of input == success
</span><span class="cx">         __ cmpl_rr(lengthRegister, currentPositionRegister);
</span><del>-        nextIsNewline.append(__ emitUnlinkedJe());
</del><ins>+        nextIsNewline.append(__ je());
</ins><span class="cx"> 
</span><span class="cx">         // now check next char against newline characters.
</span><span class="cx">         __ movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
</span><span class="cx">         generateCharacterClassInverted(nextIsNewline, CharacterClass::newline());
</span><span class="cx"> 
</span><del>-        failures.append(__ emitUnlinkedJmp());
</del><ins>+        failures.append(__ jmp());
</ins><span class="cx"> 
</span><span class="cx">         JmpDst success = __ label();
</span><span class="cx">         for (unsigned i = 0; i &lt; nextIsNewline.size(); ++i)
</span><span class="lines">@@ -531,7 +531,7 @@
</span><span class="cx">         nextIsNewline.clear();
</span><span class="cx">     } else {
</span><span class="cx">         __ cmpl_rr(lengthRegister, currentPositionRegister);
</span><del>-        failures.append(__ emitUnlinkedJne());
</del><ins>+        failures.append(__ jne());
</ins><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -544,7 +544,7 @@
</span><span class="cx"> 
</span><span class="cx">     // (1.1) check for begin of input
</span><span class="cx">     __ cmpl_i8r(0, currentPositionRegister);
</span><del>-    JmpSrc atBegin = __ emitUnlinkedJe();
</del><ins>+    JmpSrc atBegin = __ je();
</ins><span class="cx">     // (1.2) load the last char, and chck if is word character
</span><span class="cx">     __ movzwl_mr(-2, inputRegister, currentPositionRegister, 2, currentValueRegister);
</span><span class="cx">     JmpSrcVector previousIsWord;
</span><span class="lines">@@ -556,12 +556,12 @@
</span><span class="cx"> 
</span><span class="cx">     // (2.1) check for end of input
</span><span class="cx">     __ cmpl_rr(lengthRegister, currentPositionRegister);
</span><del>-    notWordBoundary.append(__ emitUnlinkedJe());
</del><ins>+    notWordBoundary.append(__ je());
</ins><span class="cx">     // (2.2) load the next char, and chck if is word character
</span><span class="cx">     __ movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
</span><span class="cx">     generateCharacterClassInverted(wordBoundary, CharacterClass::wordchar());
</span><span class="cx">     // (2.3) If we get here, neither chars are word chars
</span><del>-    notWordBoundary.append(__ emitUnlinkedJmp());
</del><ins>+    notWordBoundary.append(__ jmp());
</ins><span class="cx"> 
</span><span class="cx">     // (3) Handle situation where previous was a \w
</span><span class="cx"> 
</span><span class="lines">@@ -572,7 +572,7 @@
</span><span class="cx">     previousIsWord.clear();
</span><span class="cx">     // (3.1) check for end of input
</span><span class="cx">     __ cmpl_rr(lengthRegister, currentPositionRegister);
</span><del>-    wordBoundary.append(__ emitUnlinkedJe());
</del><ins>+    wordBoundary.append(__ je());
</ins><span class="cx">     // (3.2) load the next char, and chck if is word character
</span><span class="cx">     __ movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
</span><span class="cx">     generateCharacterClassInverted(notWordBoundary, CharacterClass::wordchar());
</span><span class="lines">@@ -582,7 +582,7 @@
</span><span class="cx">     
</span><span class="cx">     if (invert) {
</span><span class="cx">         // handle the fall through case
</span><del>-        wordBoundary.append(__ emitUnlinkedJmp());
</del><ins>+        wordBoundary.append(__ jmp());
</ins><span class="cx">     
</span><span class="cx">         // looking for non word boundaries, so link boundary fails to here.
</span><span class="cx">         JmpDst success = __ label();
</span><span class="lines">@@ -610,7 +610,7 @@
</span><span class="cx">     // get the start pos of the backref into quantifierCountRegister (multipurpose!)
</span><span class="cx">     __ movl_mr((2 * subpatternId) * sizeof(int), outputRegister, quantifierCountRegister);
</span><span class="cx"> 
</span><del>-    JmpSrc skipIncrement = __ emitUnlinkedJmp();
</del><ins>+    JmpSrc skipIncrement = __ jmp();
</ins><span class="cx">     JmpDst topOfLoop = __ label();
</span><span class="cx">     __ addl_i8r(1, currentPositionRegister);
</span><span class="cx">     __ addl_i8r(1, quantifierCountRegister);
</span><span class="lines">@@ -618,22 +618,22 @@
</span><span class="cx"> 
</span><span class="cx">     // check if we're at the end of backref (if we are, success!)
</span><span class="cx">     __ cmpl_rm(quantifierCountRegister, ((2 * subpatternId) + 1) * sizeof(int), outputRegister);
</span><del>-    JmpSrc endOfBackRef = __ emitUnlinkedJe();
</del><ins>+    JmpSrc endOfBackRef = __ je();
</ins><span class="cx">     
</span><span class="cx">     __ movzwl_mr(inputRegister, quantifierCountRegister, 2, currentValueRegister);
</span><span class="cx">     
</span><span class="cx">     // check if we've run out of input (this would be a can o'fail)
</span><span class="cx">     __ cmpl_rr(lengthRegister, currentPositionRegister);
</span><del>-    JmpSrc endOfInput = __ emitUnlinkedJe();
</del><ins>+    JmpSrc endOfInput = __ je();
</ins><span class="cx">     
</span><span class="cx">     __ cmpw_rm(currentValueRegister, inputRegister, currentPositionRegister, 2);
</span><del>-    __ link(__ emitUnlinkedJe(), topOfLoop);
</del><ins>+    __ link(__ je(), topOfLoop);
</ins><span class="cx">     
</span><span class="cx">     __ link(endOfInput, __ label());
</span><span class="cx">     // Failure
</span><span class="cx">     __ popl_r(quantifierCountRegister);
</span><span class="cx">     __ popl_r(currentPositionRegister);
</span><del>-    failures.append(__ emitUnlinkedJmp());
</del><ins>+    failures.append(__ jmp());
</ins><span class="cx">     
</span><span class="cx">     // Success
</span><span class="cx">     __ link(endOfBackRef, __ label());
</span><span class="lines">@@ -643,7 +643,7 @@
</span><span class="cx"> 
</span><span class="cx"> void Generator::generateDisjunction(JmpSrcVector&amp; successes, JmpSrcVector&amp; failures)
</span><span class="cx"> {
</span><del>-    successes.append(__ emitUnlinkedJmp());
</del><ins>+    successes.append(__ jmp());
</ins><span class="cx">     
</span><span class="cx">     JmpDst here = __ label();
</span><span class="cx">     
</span></span></pre>
</div>
</div>

</body>
</html>