2008-09-09 Cameron Zwarich <cwzwarich@uwaterloo.ca>
authorcwzwarich@webkit.org <cwzwarich@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 9 Sep 2008 22:35:29 +0000 (22:35 +0000)
committercwzwarich@webkit.org <cwzwarich@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 9 Sep 2008 22:35:29 +0000 (22:35 +0000)
        Reviewed by Sam Weinig.

        Bug 20754: Remove emit prefix from assembler opcode methods
        <https://bugs.webkit.org/show_bug.cgi?id=20754>

        * VM/CTI.cpp:
        (JSC::CTI::emitGetArg):
        (JSC::CTI::emitGetPutArg):
        (JSC::CTI::emitPutArg):
        (JSC::CTI::emitPutArgConstant):
        (JSC::CTI::emitPutCTIParam):
        (JSC::CTI::emitGetCTIParam):
        (JSC::CTI::emitPutToCallFrameHeader):
        (JSC::CTI::emitGetFromCallFrameHeader):
        (JSC::CTI::emitPutResult):
        (JSC::CTI::emitDebugExceptionCheck):
        (JSC::CTI::emitCall):
        (JSC::CTI::emitJumpSlowCaseIfNotImm):
        (JSC::CTI::emitJumpSlowCaseIfNotImms):
        (JSC::CTI::emitFastArithDeTagImmediate):
        (JSC::CTI::emitFastArithReTagImmediate):
        (JSC::CTI::emitFastArithPotentiallyReTagImmediate):
        (JSC::CTI::emitFastArithImmToInt):
        (JSC::CTI::emitFastArithIntToImmOrSlowCase):
        (JSC::CTI::emitFastArithIntToImmNoCheck):
        (JSC::CTI::compileOpCall):
        (JSC::CTI::emitSlowScriptCheck):
        (JSC::CTI::privateCompileMainPass):
        (JSC::CTI::privateCompileSlowCases):
        (JSC::CTI::privateCompile):
        (JSC::CTI::privateCompileGetByIdSelf):
        (JSC::CTI::privateCompileGetByIdProto):
        (JSC::CTI::privateCompileGetByIdChain):
        (JSC::CTI::privateCompilePutByIdReplace):
        (JSC::CTI::privateArrayLengthTrampoline):
        (JSC::CTI::privateStringLengthTrampoline):
        (JSC::CTI::compileRegExp):
        * masm/MacroAssemblerWin.cpp:
        (JSC::MacroAssembler::emitConvertToFastCall):
        (JSC::MacroAssembler::emitRestoreArgumentReference):
        * masm/X86Assembler.h:
        (JSC::X86Assembler::pushl_r):
        (JSC::X86Assembler::pushl_m):
        (JSC::X86Assembler::popl_r):
        (JSC::X86Assembler::popl_m):
        (JSC::X86Assembler::movl_rr):
        (JSC::X86Assembler::addl_rr):
        (JSC::X86Assembler::addl_i8r):
        (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_i32r):
        (JSC::X86Assembler::cmpl_i32m):
        (JSC::X86Assembler::cmpw_rm):
        (JSC::X86Assembler::orl_rr):
        (JSC::X86Assembler::subl_rr):
        (JSC::X86Assembler::subl_i8r):
        (JSC::X86Assembler::subl_i32r):
        (JSC::X86Assembler::subl_mr):
        (JSC::X86Assembler::testl_i32r):
        (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::mull_rr):
        (JSC::X86Assembler::idivl_r):
        (JSC::X86Assembler::cdq):
        (JSC::X86Assembler::movl_mr):
        (JSC::X86Assembler::movzwl_mr):
        (JSC::X86Assembler::movl_rm):
        (JSC::X86Assembler::movl_i32r):
        (JSC::X86Assembler::movl_i32m):
        (JSC::X86Assembler::leal_mr):
        (JSC::X86Assembler::ret):
        (JSC::X86Assembler::jmp_r):
        (JSC::X86Assembler::jmp_m):
        (JSC::X86Assembler::call_r):
        * wrec/WREC.cpp:
        (JSC::WRECGenerator::generateBacktrack1):
        (JSC::WRECGenerator::generateBacktrackBackreference):
        (JSC::WRECGenerator::generateBackreferenceQuantifier):
        (JSC::WRECGenerator::generateNonGreedyQuantifier):
        (JSC::WRECGenerator::generateGreedyQuantifier):
        (JSC::WRECGenerator::generatePatternCharacter):
        (JSC::WRECGenerator::generateCharacterClassInvertedRange):
        (JSC::WRECGenerator::generateCharacterClassInverted):
        (JSC::WRECGenerator::generateCharacterClass):
        (JSC::WRECGenerator::generateParentheses):
        (JSC::WRECGenerator::gererateParenthesesResetTrampoline):
        (JSC::WRECGenerator::generateAssertionBOL):
        (JSC::WRECGenerator::generateAssertionEOL):
        (JSC::WRECGenerator::generateAssertionWordBoundary):
        (JSC::WRECGenerator::generateBackreference):
        (JSC::WRECGenerator::gernerateDisjunction):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@36301 268f45cc-cd09-0410-ab3c-d52691b4dbfc

JavaScriptCore/ChangeLog
JavaScriptCore/VM/CTI.cpp
JavaScriptCore/masm/MacroAssemblerWin.cpp
JavaScriptCore/masm/X86Assembler.h
JavaScriptCore/wrec/WREC.cpp

index 34cc594..331d6ea 100644 (file)
@@ -1,5 +1,109 @@
 2008-09-09  Cameron Zwarich  <cwzwarich@uwaterloo.ca>
 
+        Reviewed by Sam Weinig.
+
+        Bug 20754: Remove emit prefix from assembler opcode methods
+        <https://bugs.webkit.org/show_bug.cgi?id=20754>
+
+        * VM/CTI.cpp:
+        (JSC::CTI::emitGetArg):
+        (JSC::CTI::emitGetPutArg):
+        (JSC::CTI::emitPutArg):
+        (JSC::CTI::emitPutArgConstant):
+        (JSC::CTI::emitPutCTIParam):
+        (JSC::CTI::emitGetCTIParam):
+        (JSC::CTI::emitPutToCallFrameHeader):
+        (JSC::CTI::emitGetFromCallFrameHeader):
+        (JSC::CTI::emitPutResult):
+        (JSC::CTI::emitDebugExceptionCheck):
+        (JSC::CTI::emitCall):
+        (JSC::CTI::emitJumpSlowCaseIfNotImm):
+        (JSC::CTI::emitJumpSlowCaseIfNotImms):
+        (JSC::CTI::emitFastArithDeTagImmediate):
+        (JSC::CTI::emitFastArithReTagImmediate):
+        (JSC::CTI::emitFastArithPotentiallyReTagImmediate):
+        (JSC::CTI::emitFastArithImmToInt):
+        (JSC::CTI::emitFastArithIntToImmOrSlowCase):
+        (JSC::CTI::emitFastArithIntToImmNoCheck):
+        (JSC::CTI::compileOpCall):
+        (JSC::CTI::emitSlowScriptCheck):
+        (JSC::CTI::privateCompileMainPass):
+        (JSC::CTI::privateCompileSlowCases):
+        (JSC::CTI::privateCompile):
+        (JSC::CTI::privateCompileGetByIdSelf):
+        (JSC::CTI::privateCompileGetByIdProto):
+        (JSC::CTI::privateCompileGetByIdChain):
+        (JSC::CTI::privateCompilePutByIdReplace):
+        (JSC::CTI::privateArrayLengthTrampoline):
+        (JSC::CTI::privateStringLengthTrampoline):
+        (JSC::CTI::compileRegExp):
+        * masm/MacroAssemblerWin.cpp:
+        (JSC::MacroAssembler::emitConvertToFastCall):
+        (JSC::MacroAssembler::emitRestoreArgumentReference):
+        * masm/X86Assembler.h:
+        (JSC::X86Assembler::pushl_r):
+        (JSC::X86Assembler::pushl_m):
+        (JSC::X86Assembler::popl_r):
+        (JSC::X86Assembler::popl_m):
+        (JSC::X86Assembler::movl_rr):
+        (JSC::X86Assembler::addl_rr):
+        (JSC::X86Assembler::addl_i8r):
+        (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_i32r):
+        (JSC::X86Assembler::cmpl_i32m):
+        (JSC::X86Assembler::cmpw_rm):
+        (JSC::X86Assembler::orl_rr):
+        (JSC::X86Assembler::subl_rr):
+        (JSC::X86Assembler::subl_i8r):
+        (JSC::X86Assembler::subl_i32r):
+        (JSC::X86Assembler::subl_mr):
+        (JSC::X86Assembler::testl_i32r):
+        (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::mull_rr):
+        (JSC::X86Assembler::idivl_r):
+        (JSC::X86Assembler::cdq):
+        (JSC::X86Assembler::movl_mr):
+        (JSC::X86Assembler::movzwl_mr):
+        (JSC::X86Assembler::movl_rm):
+        (JSC::X86Assembler::movl_i32r):
+        (JSC::X86Assembler::movl_i32m):
+        (JSC::X86Assembler::leal_mr):
+        (JSC::X86Assembler::ret):
+        (JSC::X86Assembler::jmp_r):
+        (JSC::X86Assembler::jmp_m):
+        (JSC::X86Assembler::call_r):
+        * wrec/WREC.cpp:
+        (JSC::WRECGenerator::generateBacktrack1):
+        (JSC::WRECGenerator::generateBacktrackBackreference):
+        (JSC::WRECGenerator::generateBackreferenceQuantifier):
+        (JSC::WRECGenerator::generateNonGreedyQuantifier):
+        (JSC::WRECGenerator::generateGreedyQuantifier):
+        (JSC::WRECGenerator::generatePatternCharacter):
+        (JSC::WRECGenerator::generateCharacterClassInvertedRange):
+        (JSC::WRECGenerator::generateCharacterClassInverted):
+        (JSC::WRECGenerator::generateCharacterClass):
+        (JSC::WRECGenerator::generateParentheses):
+        (JSC::WRECGenerator::gererateParenthesesResetTrampoline):
+        (JSC::WRECGenerator::generateAssertionBOL):
+        (JSC::WRECGenerator::generateAssertionEOL):
+        (JSC::WRECGenerator::generateAssertionWordBoundary):
+        (JSC::WRECGenerator::generateBackreference):
+        (JSC::WRECGenerator::gernerateDisjunction):
+
+2008-09-09  Cameron Zwarich  <cwzwarich@uwaterloo.ca>
+
         Reviewed by Maciej Stachowiak.
 
         Clean up the WREC code some more.
index f39e4aa..19eff93 100644 (file)
@@ -112,9 +112,9 @@ ALWAYS_INLINE void CTI::emitGetArg(unsigned src, MacroAssembler::RegisterID dst)
     // TODO: we want to reuse values that are already in registers if we can - add a register allocator!
     if (src < m_codeBlock->constantRegisters.size()) {
         JSValue* js = m_codeBlock->constantRegisters[src].jsValue(m_exec);
-        m_jit.emitMovl_i32r(reinterpret_cast<unsigned>(js), dst);
+        m_jit.movl_i32r(reinterpret_cast<unsigned>(js), dst);
     } else
-        m_jit.emitMovl_mr(src * sizeof(Register), MacroAssembler::edi, dst);
+        m_jit.movl_mr(src * sizeof(Register), MacroAssembler::edi, dst);
 }
 
 // get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function.
@@ -122,22 +122,22 @@ ALWAYS_INLINE void CTI::emitGetPutArg(unsigned src, unsigned offset, MacroAssemb
 {
     if (src < m_codeBlock->constantRegisters.size()) {
         JSValue* js = m_codeBlock->constantRegisters[src].jsValue(m_exec);
-        m_jit.emitMovl_i32m(reinterpret_cast<unsigned>(js), offset + sizeof(void*), MacroAssembler::esp);
+        m_jit.movl_i32m(reinterpret_cast<unsigned>(js), offset + sizeof(void*), MacroAssembler::esp);
     } else {
-        m_jit.emitMovl_mr(src * sizeof(Register), MacroAssembler::edi, scratch);
-        m_jit.emitMovl_rm(scratch, offset + sizeof(void*), MacroAssembler::esp);
+        m_jit.movl_mr(src * sizeof(Register), MacroAssembler::edi, scratch);
+        m_jit.movl_rm(scratch, offset + sizeof(void*), MacroAssembler::esp);
     }
 }
 
 // puts an arg onto the stack, as an arg to a context threaded function.
 ALWAYS_INLINE void CTI::emitPutArg(MacroAssembler::RegisterID src, unsigned offset)
 {
-    m_jit.emitMovl_rm(src, offset + sizeof(void*), MacroAssembler::esp);
+    m_jit.movl_rm(src, offset + sizeof(void*), MacroAssembler::esp);
 }
 
 ALWAYS_INLINE void CTI::emitPutArgConstant(unsigned value, unsigned offset)
 {
-    m_jit.emitMovl_i32m(value, offset + sizeof(void*), MacroAssembler::esp);
+    m_jit.movl_i32m(value, offset + sizeof(void*), MacroAssembler::esp);
 }
 
 ALWAYS_INLINE JSValue* CTI::getConstantImmediateNumericArg(unsigned src)
@@ -151,27 +151,27 @@ ALWAYS_INLINE JSValue* CTI::getConstantImmediateNumericArg(unsigned src)
 
 ALWAYS_INLINE void CTI::emitPutCTIParam(MacroAssembler::RegisterID from, unsigned name)
 {
-    m_jit.emitMovl_rm(from, name * sizeof(void*), MacroAssembler::esp);
+    m_jit.movl_rm(from, name * sizeof(void*), MacroAssembler::esp);
 }
 
 ALWAYS_INLINE void CTI::emitGetCTIParam(unsigned name, MacroAssembler::RegisterID to)
 {
-    m_jit.emitMovl_mr(name * sizeof(void*), MacroAssembler::esp, to);
+    m_jit.movl_mr(name * sizeof(void*), MacroAssembler::esp, to);
 }
 
 ALWAYS_INLINE void CTI::emitPutToCallFrameHeader(MacroAssembler::RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
 {
-    m_jit.emitMovl_rm(from, -((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - entry) * sizeof(Register), MacroAssembler::edi);
+    m_jit.movl_rm(from, -((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - entry) * sizeof(Register), MacroAssembler::edi);
 }
 
 ALWAYS_INLINE void CTI::emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, MacroAssembler::RegisterID to)
 {
-    m_jit.emitMovl_mr(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - entry) * sizeof(Register), MacroAssembler::edi, to);
+    m_jit.movl_mr(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - entry) * sizeof(Register), MacroAssembler::edi, to);
 }
 
 ALWAYS_INLINE void CTI::emitPutResult(unsigned dst, MacroAssembler::RegisterID from)
 {
-    m_jit.emitMovl_rm(from, dst * sizeof(Register), MacroAssembler::edi);
+    m_jit.movl_rm(from, dst * sizeof(Register), MacroAssembler::edi);
     // FIXME: #ifndef NDEBUG, Write the correct m_type to the register.
 }
 
@@ -200,7 +200,7 @@ ALWAYS_INLINE void CTI::emitDebugExceptionCheck()
 ALWAYS_INLINE void CTI::emitDebugExceptionCheck()
 {
     emitGetCTIParam(CTI_ARGS_exec, MacroAssembler::ecx);
-    m_jit.emitCmpl_i32m(0, OBJECT_OFFSET(ExecState, m_exception), MacroAssembler::ecx);
+    m_jit.cmpl_i32m(0, OBJECT_OFFSET(ExecState, m_exception), MacroAssembler::ecx);
     MacroAssembler::JmpSrc noException = m_jit.emitUnlinkedJe();
     m_jit.emitInt3();
     m_jit.link(noException, m_jit.label());
@@ -245,73 +245,73 @@ void CTI::printOpcodeOperandTypes(unsigned src1, unsigned src2)
 ALWAYS_INLINE void CTI::emitCall(unsigned opcodeIndex, CTIHelper_j helper)
 {
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(1, &incall);
+    m_jit.movl_i32m(1, &incall);
 #endif
     m_calls.append(CallRecord(m_jit.emitCall(), helper, opcodeIndex));
     emitDebugExceptionCheck();
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(0, &incall);
+    m_jit.movl_i32m(0, &incall);
 #endif
 }
 
 ALWAYS_INLINE void CTI::emitCall(unsigned opcodeIndex, CTIHelper_p helper)
 {
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(1, &incall);
+    m_jit.movl_i32m(1, &incall);
 #endif
     m_calls.append(CallRecord(m_jit.emitCall(), helper, opcodeIndex));
     emitDebugExceptionCheck();
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(0, &incall);
+    m_jit.movl_i32m(0, &incall);
 #endif
 }
 
 ALWAYS_INLINE void CTI::emitCall(unsigned opcodeIndex, CTIHelper_b helper)
 {
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(1, &incall);
+    m_jit.movl_i32m(1, &incall);
 #endif
     m_calls.append(CallRecord(m_jit.emitCall(), helper, opcodeIndex));
     emitDebugExceptionCheck();
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(0, &incall);
+    m_jit.movl_i32m(0, &incall);
 #endif
 }
 
 ALWAYS_INLINE void CTI::emitCall(unsigned opcodeIndex, CTIHelper_v helper)
 {
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(1, &incall);
+    m_jit.movl_i32m(1, &incall);
 #endif
     m_calls.append(CallRecord(m_jit.emitCall(), helper, opcodeIndex));
     emitDebugExceptionCheck();
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(0, &incall);
+    m_jit.movl_i32m(0, &incall);
 #endif
 }
 
 ALWAYS_INLINE void CTI::emitCall(unsigned opcodeIndex, CTIHelper_s helper)
 {
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(1, &incall);
+    m_jit.movl_i32m(1, &incall);
 #endif
     m_calls.append(CallRecord(m_jit.emitCall(), helper, opcodeIndex));
     emitDebugExceptionCheck();
 #if ENABLE(SAMPLING_TOOL)
-    m_jit.emitMovl_i32m(0, &incall);
+    m_jit.movl_i32m(0, &incall);
 #endif
 }
 
 ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotImm(MacroAssembler::RegisterID reg, unsigned opcodeIndex)
 {
-    m_jit.emitTestl_i32r(JSImmediate::TagBitTypeInteger, reg);
+    m_jit.testl_i32r(JSImmediate::TagBitTypeInteger, reg);
     m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJe(), opcodeIndex));
 }
 
 ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotImms(MacroAssembler::RegisterID reg1, MacroAssembler::RegisterID reg2, unsigned opcodeIndex)
 {
-    m_jit.emitMovl_rr(reg1, MacroAssembler::ecx);
-    m_jit.emitAndl_rr(reg2, MacroAssembler::ecx);
+    m_jit.movl_rr(reg1, MacroAssembler::ecx);
+    m_jit.andl_rr(reg2, MacroAssembler::ecx);
     emitJumpSlowCaseIfNotImm(MacroAssembler::ecx, opcodeIndex);
 }
 
@@ -324,34 +324,34 @@ ALWAYS_INLINE unsigned CTI::getDeTaggedConstantImmediate(JSValue* imm)
 ALWAYS_INLINE void CTI::emitFastArithDeTagImmediate(MacroAssembler::RegisterID reg)
 {
     // op_mod relies on this being a sub - setting zf if result is 0.
-    m_jit.emitSubl_i8r(JSImmediate::TagBitTypeInteger, reg);
+    m_jit.subl_i8r(JSImmediate::TagBitTypeInteger, reg);
 }
 
 ALWAYS_INLINE void CTI::emitFastArithReTagImmediate(MacroAssembler::RegisterID reg)
 {
-    m_jit.emitAddl_i8r(JSImmediate::TagBitTypeInteger, reg);
+    m_jit.addl_i8r(JSImmediate::TagBitTypeInteger, reg);
 }
 
 ALWAYS_INLINE void CTI::emitFastArithPotentiallyReTagImmediate(MacroAssembler::RegisterID reg)
 {
-    m_jit.emitOrl_i8r(JSImmediate::TagBitTypeInteger, reg);
+    m_jit.orl_rr(JSImmediate::TagBitTypeInteger, reg);
 }
 
 ALWAYS_INLINE void CTI::emitFastArithImmToInt(MacroAssembler::RegisterID reg)
 {
-    m_jit.emitSarl_i8r(1, reg);
+    m_jit.sarl_i8r(1, reg);
 }
 
 ALWAYS_INLINE void CTI::emitFastArithIntToImmOrSlowCase(MacroAssembler::RegisterID reg, unsigned opcodeIndex)
 {
-    m_jit.emitAddl_rr(reg, reg);
+    m_jit.addl_rr(reg, reg);
     m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), opcodeIndex));
     emitFastArithReTagImmediate(reg);
 }
 
 ALWAYS_INLINE void CTI::emitFastArithIntToImmNoCheck(MacroAssembler::RegisterID reg)
 {
-    m_jit.emitAddl_rr(reg, reg);
+    m_jit.addl_rr(reg, reg);
     emitFastArithReTagImmediate(reg);
 }
 
@@ -404,7 +404,7 @@ void CTI::compileOpCall(Instruction* instruction, unsigned i, CompileOpCallType
 
        emitGetCTIParam(CTI_ARGS_r, MacroAssembler::edi); // edi := r
 
-        m_jit.emitCmpl_i32r(reinterpret_cast<unsigned>(JSImmediate::impossibleValue()), MacroAssembler::eax);
+        m_jit.cmpl_i32r(reinterpret_cast<unsigned>(JSImmediate::impossibleValue()), MacroAssembler::eax);
         wasEval = m_jit.emitUnlinkedJne();
     
         // this reloads the first arg into ecx (checked just below).
@@ -416,9 +416,9 @@ void CTI::compileOpCall(Instruction* instruction, unsigned i, CompileOpCallType
     }
 
     // Fast check for JS function.
-    m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::ecx);
+    m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::ecx);
     MacroAssembler::JmpSrc isNotObject = m_jit.emitUnlinkedJne();
-    m_jit.emitCmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsFunctionVptr), MacroAssembler::ecx);
+    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsFunctionVptr), MacroAssembler::ecx);
     MacroAssembler::JmpSrc isJSFunction = m_jit.emitUnlinkedJe();
     m_jit.link(isNotObject, m_jit.label());
 
@@ -431,7 +431,7 @@ void CTI::compileOpCall(Instruction* instruction, unsigned i, CompileOpCallType
 
     // This handles JSFunctions
     emitCall(i, ((type == OpConstruct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction));
-    m_jit.emitCallN_r(MacroAssembler::eax);
+    m_jit.call_r(MacroAssembler::eax);
     emitGetCTIParam(CTI_ARGS_r, MacroAssembler::edi); // edi := r
 
     MacroAssembler::JmpDst end = m_jit.label();
@@ -444,14 +444,14 @@ void CTI::compileOpCall(Instruction* instruction, unsigned i, CompileOpCallType
 
 void CTI::emitSlowScriptCheck(unsigned opcodeIndex)
 {
-    m_jit.emitSubl_i8r(1, MacroAssembler::esi);
+    m_jit.subl_i8r(1, MacroAssembler::esi);
     MacroAssembler::JmpSrc skipTimeout = m_jit.emitUnlinkedJne();
     emitCall(opcodeIndex, Machine::cti_timeout_check);
 
     emitGetCTIParam(CTI_ARGS_exec, MacroAssembler::ecx);
-    m_jit.emitMovl_mr(OBJECT_OFFSET(ExecState, m_globalData), MacroAssembler::ecx, MacroAssembler::ecx);
-    m_jit.emitMovl_mr(OBJECT_OFFSET(JSGlobalData, machine), MacroAssembler::ecx, MacroAssembler::ecx);
-    m_jit.emitMovl_mr(OBJECT_OFFSET(Machine, m_ticksUntilNextTimeoutCheck), MacroAssembler::ecx, MacroAssembler::esi);
+    m_jit.movl_mr(OBJECT_OFFSET(ExecState, m_globalData), MacroAssembler::ecx, MacroAssembler::ecx);
+    m_jit.movl_mr(OBJECT_OFFSET(JSGlobalData, machine), MacroAssembler::ecx, MacroAssembler::ecx);
+    m_jit.movl_mr(OBJECT_OFFSET(Machine, m_ticksUntilNextTimeoutCheck), MacroAssembler::ecx, MacroAssembler::esi);
     m_jit.link(skipTimeout, m_jit.label());
 }
 
@@ -464,7 +464,7 @@ void CTI::privateCompileMainPass()
         m_labels[i] = m_jit.label();
 
 #if ENABLE(SAMPLING_TOOL)
-        m_jit.emitMovl_i32m(m_machine->getOpcodeID(instruction[i].u.opcode), &what);
+        m_jit.movl_i32m(m_machine->getOpcodeID(instruction[i].u.opcode), &what);
 #endif
 
         ASSERT_WITH_MESSAGE(m_machine->isOpcode(instruction[i].u.opcode), "privateCompileMainPass gone bad @ %d", i);
@@ -473,7 +473,7 @@ void CTI::privateCompileMainPass()
         case op_mov: {
             unsigned src = instruction[i + 2].u.operand;
             if (src < m_codeBlock->constantRegisters.size())
-                m_jit.emitMovl_i32r(reinterpret_cast<unsigned>(m_codeBlock->constantRegisters[src].jsValue(m_exec)), MacroAssembler::edx);
+                m_jit.movl_i32r(reinterpret_cast<unsigned>(m_codeBlock->constantRegisters[src].jsValue(m_exec)), MacroAssembler::edx);
             else
                 emitGetArg(src, MacroAssembler::edx);
             emitPutResult(instruction[i + 1].u.operand, MacroAssembler::edx);
@@ -489,7 +489,7 @@ void CTI::privateCompileMainPass()
                 if (JSImmediate::isNumber(value)) {
                     emitGetArg(src1, MacroAssembler::eax);
                     emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-                    m_jit.emitAddl_i32r(getDeTaggedConstantImmediate(value), MacroAssembler::eax);
+                    m_jit.addl_i32r(getDeTaggedConstantImmediate(value), MacroAssembler::eax);
                     m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
                     emitPutResult(dst);
                     i += 4;
@@ -500,7 +500,7 @@ void CTI::privateCompileMainPass()
                 emitGetArg(src2, MacroAssembler::edx);
                 emitJumpSlowCaseIfNotImms(MacroAssembler::eax, MacroAssembler::edx, i);
                 emitFastArithDeTagImmediate(MacroAssembler::eax);
-                m_jit.emitAddl_rr(MacroAssembler::edx, MacroAssembler::eax);
+                m_jit.addl_rr(MacroAssembler::edx, MacroAssembler::eax);
                 m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
                 emitPutResult(dst);
                 i += 4;
@@ -518,10 +518,10 @@ void CTI::privateCompileMainPass()
                 emitCall(i, Machine::cti_op_end);
             emitGetArg(instruction[i + 1].u.operand, MacroAssembler::eax);
 #if ENABLE(SAMPLING_TOOL)
-            m_jit.emitMovl_i32m(-1, &what);
+            m_jit.movl_i32m(-1, &what);
 #endif
-            m_jit.emitPushl_m(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - RegisterFile::CTIReturnEIP) * sizeof(Register), MacroAssembler::edi);
-            m_jit.emitRet();
+            m_jit.pushl_m(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - RegisterFile::CTIReturnEIP) * sizeof(Register), MacroAssembler::edi);
+            m_jit.ret();
             i += 2;
             break;
         }
@@ -535,7 +535,7 @@ void CTI::privateCompileMainPass()
             int srcDst = instruction[i + 1].u.operand;
             emitGetArg(srcDst, MacroAssembler::eax);
             emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-            m_jit.emitAddl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
+            m_jit.addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
             emitPutResult(srcDst, MacroAssembler::eax);
             i += 2;
@@ -557,14 +557,14 @@ void CTI::privateCompileMainPass()
             if (src2imm) {
                 emitGetArg(instruction[i + 1].u.operand, MacroAssembler::edx);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::edx, i);
-                m_jit.emitCmpl_i32r(reinterpret_cast<unsigned>(src2imm), MacroAssembler::edx);
+                m_jit.cmpl_i32r(reinterpret_cast<unsigned>(src2imm), MacroAssembler::edx);
                 m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJl(), i + 3 + target));
             } else {
                 emitGetArg(instruction[i + 1].u.operand, MacroAssembler::eax);
                 emitGetArg(instruction[i + 2].u.operand, MacroAssembler::edx);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::edx, i);
-                m_jit.emitCmpl_rr(MacroAssembler::edx, MacroAssembler::eax);
+                m_jit.cmpl_rr(MacroAssembler::edx, MacroAssembler::eax);
                 m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJl(), i + 3 + target));
             }
             i += 4;
@@ -633,12 +633,12 @@ void CTI::privateCompileMainPass()
 
             emitGetCTIParam(CTI_ARGS_scopeChain, MacroAssembler::eax);
             while (skip--)
-                m_jit.emitMovl_mr(OBJECT_OFFSET(ScopeChainNode, next), MacroAssembler::eax, MacroAssembler::eax);
+                m_jit.movl_mr(OBJECT_OFFSET(ScopeChainNode, next), MacroAssembler::eax, MacroAssembler::eax);
 
-            m_jit.emitMovl_mr(OBJECT_OFFSET(ScopeChainNode, object), MacroAssembler::eax, MacroAssembler::eax);
-            m_jit.emitMovl_mr(JSVariableObject::offsetOf_d(), MacroAssembler::eax, MacroAssembler::eax);
-            m_jit.emitMovl_mr(JSVariableObject::offsetOf_Data_registers(), MacroAssembler::eax, MacroAssembler::eax);
-            m_jit.emitMovl_mr((instruction[i + 2].u.operand) * sizeof(Register), MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.movl_mr(OBJECT_OFFSET(ScopeChainNode, object), MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.movl_mr(JSVariableObject::offsetOf_d(), MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.movl_mr(JSVariableObject::offsetOf_Data_registers(), MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.movl_mr((instruction[i + 2].u.operand) * sizeof(Register), MacroAssembler::eax, MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -649,12 +649,12 @@ void CTI::privateCompileMainPass()
             emitGetCTIParam(CTI_ARGS_scopeChain, MacroAssembler::edx);
             emitGetArg(instruction[i + 3].u.operand, MacroAssembler::eax);
             while (skip--)
-                m_jit.emitMovl_mr(OBJECT_OFFSET(ScopeChainNode, next), MacroAssembler::edx, MacroAssembler::edx);
+                m_jit.movl_mr(OBJECT_OFFSET(ScopeChainNode, next), MacroAssembler::edx, MacroAssembler::edx);
 
-            m_jit.emitMovl_mr(OBJECT_OFFSET(ScopeChainNode, object), MacroAssembler::edx, MacroAssembler::edx);
-            m_jit.emitMovl_mr(JSVariableObject::offsetOf_d(), MacroAssembler::edx, MacroAssembler::edx);
-            m_jit.emitMovl_mr(JSVariableObject::offsetOf_Data_registers(), MacroAssembler::edx, MacroAssembler::edx);
-            m_jit.emitMovl_rm(MacroAssembler::eax, (instruction[i + 1].u.operand) * sizeof(Register), MacroAssembler::edx);
+            m_jit.movl_mr(OBJECT_OFFSET(ScopeChainNode, object), MacroAssembler::edx, MacroAssembler::edx);
+            m_jit.movl_mr(JSVariableObject::offsetOf_d(), MacroAssembler::edx, MacroAssembler::edx);
+            m_jit.movl_mr(JSVariableObject::offsetOf_Data_registers(), MacroAssembler::edx, MacroAssembler::edx);
+            m_jit.movl_rm(MacroAssembler::eax, (instruction[i + 1].u.operand) * sizeof(Register), MacroAssembler::edx);
             i += 4;
             break;
         }
@@ -662,13 +662,13 @@ void CTI::privateCompileMainPass()
             emitGetPutArg(instruction[i + 1].u.operand, 0, MacroAssembler::ecx);
             emitCall(i, Machine::cti_op_ret);
 
-            m_jit.emitPushl_m(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - RegisterFile::CTIReturnEIP) * sizeof(Register), MacroAssembler::edi);
-            m_jit.emitRet();
+            m_jit.pushl_m(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - RegisterFile::CTIReturnEIP) * sizeof(Register), MacroAssembler::edi);
+            m_jit.ret();
             i += 2;
             break;
         }
         case op_new_array: {
-            m_jit.emitLeal_mr(sizeof(Register) * instruction[i + 2].u.operand, MacroAssembler::edi, MacroAssembler::edx);
+            m_jit.leal_mr(sizeof(Register) * instruction[i + 2].u.operand, MacroAssembler::edi, MacroAssembler::edx);
             emitPutArg(MacroAssembler::edx, 0);
             emitPutArgConstant(instruction[i + 3].u.operand, 4);
             emitCall(i, Machine::cti_op_new_array);
@@ -694,15 +694,15 @@ void CTI::privateCompileMainPass()
             emitGetArg(instruction[i + 3].u.operand, MacroAssembler::edx);
             emitJumpSlowCaseIfNotImm(MacroAssembler::edx, i);
             emitFastArithImmToInt(MacroAssembler::edx);
-            m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+            m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
-            m_jit.emitCmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), MacroAssembler::eax);
+            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
-            m_jit.emitCmpl_rm(MacroAssembler::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), MacroAssembler::eax);
+            m_jit.cmpl_rm(MacroAssembler::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJbe(), i));
 
-            m_jit.emitMovl_mr(OBJECT_OFFSET(JSArray, m_storage), MacroAssembler::eax, MacroAssembler::eax);
-            m_jit.emitMovl_mr(OBJECT_OFFSET(ArrayStorage, m_vector[0]), MacroAssembler::eax, MacroAssembler::edx, sizeof(JSValue*), MacroAssembler::eax);
+            m_jit.movl_mr(OBJECT_OFFSET(JSArray, m_storage), MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.movl_mr(OBJECT_OFFSET(ArrayStorage, m_vector[0]), MacroAssembler::eax, MacroAssembler::edx, sizeof(JSValue*), MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -721,7 +721,7 @@ void CTI::privateCompileMainPass()
             emitGetArg(instruction[i + 2].u.operand, MacroAssembler::eax);
             emitGetArg(instruction[i + 3].u.operand, MacroAssembler::edx);
             emitJumpSlowCaseIfNotImms(MacroAssembler::eax, MacroAssembler::edx, i);
-            m_jit.emitSubl_rr(MacroAssembler::edx, MacroAssembler::eax);
+            m_jit.subl_rr(MacroAssembler::edx, MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
             emitFastArithReTagImmediate(MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
@@ -734,15 +734,15 @@ void CTI::privateCompileMainPass()
             emitGetArg(instruction[i + 3].u.operand, MacroAssembler::ecx);
             emitJumpSlowCaseIfNotImm(MacroAssembler::edx, i);
             emitFastArithImmToInt(MacroAssembler::edx);
-            m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+            m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
-            m_jit.emitCmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), MacroAssembler::eax);
+            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
-            m_jit.emitCmpl_rm(MacroAssembler::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), MacroAssembler::eax);
+            m_jit.cmpl_rm(MacroAssembler::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJbe(), i));
 
-            m_jit.emitMovl_mr(OBJECT_OFFSET(JSArray, m_storage), MacroAssembler::eax, MacroAssembler::eax);
-            m_jit.emitMovl_rm(MacroAssembler::ecx, OBJECT_OFFSET(ArrayStorage, m_vector[0]), MacroAssembler::eax, MacroAssembler::edx, sizeof(JSValue*));
+            m_jit.movl_mr(OBJECT_OFFSET(JSArray, m_storage), MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.movl_rm(MacroAssembler::ecx, OBJECT_OFFSET(ArrayStorage, m_vector[0]), MacroAssembler::eax, MacroAssembler::edx, sizeof(JSValue*));
             i += 4;
             break;
         }
@@ -753,14 +753,14 @@ void CTI::privateCompileMainPass()
             unsigned target = instruction[i + 2].u.operand;
             emitGetArg(instruction[i + 1].u.operand, MacroAssembler::eax);
 
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), MacroAssembler::eax);
             MacroAssembler::JmpSrc isZero = m_jit.emitUnlinkedJe();
-            m_jit.emitTestl_i32r(JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
+            m_jit.testl_i32r(JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJne(), i + 2 + target));
 
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::trueImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::trueImmediate()), MacroAssembler::eax);
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJe(), i + 2 + target));
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::falseImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::falseImmediate()), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
 
             m_jit.link(isZero, m_jit.label());
@@ -796,7 +796,7 @@ void CTI::privateCompileMainPass()
             int srcDst = instruction[i + 1].u.operand;
             emitGetArg(srcDst, MacroAssembler::eax);
             emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-            m_jit.emitSubl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
+            m_jit.subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
             emitPutResult(srcDst, MacroAssembler::eax);
             i += 2;
@@ -808,14 +808,14 @@ void CTI::privateCompileMainPass()
             if (src2imm) {
                 emitGetArg(instruction[i + 1].u.operand, MacroAssembler::edx);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::edx, i);
-                m_jit.emitCmpl_i32r(reinterpret_cast<unsigned>(src2imm), MacroAssembler::edx);
+                m_jit.cmpl_i32r(reinterpret_cast<unsigned>(src2imm), MacroAssembler::edx);
                 m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJge(), i + 3 + target));
             } else {
                 emitGetArg(instruction[i + 1].u.operand, MacroAssembler::eax);
                 emitGetArg(instruction[i + 2].u.operand, MacroAssembler::edx);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::edx, i);
-                m_jit.emitCmpl_rr(MacroAssembler::edx, MacroAssembler::eax);
+                m_jit.cmpl_rr(MacroAssembler::edx, MacroAssembler::eax);
                 m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJge(), i + 3 + target));
             }
             i += 4;
@@ -823,10 +823,10 @@ void CTI::privateCompileMainPass()
         }
         case op_not: {
             emitGetArg(instruction[i + 2].u.operand, MacroAssembler::eax);
-            m_jit.emitXorl_i8r(JSImmediate::FullTagTypeBool, MacroAssembler::eax);
-            m_jit.emitTestl_i32r(JSImmediate::FullTagTypeMask, MacroAssembler::eax); // i8?
+            m_jit.xorl_i8r(JSImmediate::FullTagTypeBool, MacroAssembler::eax);
+            m_jit.testl_i32r(JSImmediate::FullTagTypeMask, MacroAssembler::eax); // i8?
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
-            m_jit.emitXorl_i8r((JSImmediate::FullTagTypeBool | JSImmediate::ExtendedPayloadBitBoolValue), MacroAssembler::eax);
+            m_jit.xorl_i8r((JSImmediate::FullTagTypeBool | JSImmediate::ExtendedPayloadBitBoolValue), MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -835,14 +835,14 @@ void CTI::privateCompileMainPass()
             unsigned target = instruction[i + 2].u.operand;
             emitGetArg(instruction[i + 1].u.operand, MacroAssembler::eax);
 
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), MacroAssembler::eax);
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJe(), i + 2 + target));
-            m_jit.emitTestl_i32r(JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
+            m_jit.testl_i32r(JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
             MacroAssembler::JmpSrc isNonZero = m_jit.emitUnlinkedJne();
 
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::falseImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::falseImmediate()), MacroAssembler::eax);
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJe(), i + 2 + target));
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::trueImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::trueImmediate()), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
 
             m_jit.link(isNonZero, m_jit.label());
@@ -852,9 +852,9 @@ void CTI::privateCompileMainPass()
         case op_post_inc: {
             int srcDst = instruction[i + 2].u.operand;
             emitGetArg(srcDst, MacroAssembler::eax);
-            m_jit.emitMovl_rr(MacroAssembler::eax, MacroAssembler::edx);
+            m_jit.movl_rr(MacroAssembler::eax, MacroAssembler::edx);
             emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-            m_jit.emitAddl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::edx);
+            m_jit.addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::edx);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
             emitPutResult(srcDst, MacroAssembler::edx);
             emitPutResult(instruction[i + 1].u.operand);
@@ -863,7 +863,7 @@ void CTI::privateCompileMainPass()
         }
         case op_unexpected_load: {
             JSValue* v = m_codeBlock->unexpectedConstants[instruction[i + 2].u.operand];
-            m_jit.emitMovl_i32r(reinterpret_cast<unsigned>(v), MacroAssembler::eax);
+            m_jit.movl_i32r(reinterpret_cast<unsigned>(v), MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -871,7 +871,7 @@ void CTI::privateCompileMainPass()
         case op_jsr: {
             int retAddrDst = instruction[i + 1].u.operand;
             int target = instruction[i + 2].u.operand;
-            m_jit.emitMovl_i32m(0, sizeof(Register) * retAddrDst, MacroAssembler::edi);
+            m_jit.movl_i32m(0, sizeof(Register) * retAddrDst, MacroAssembler::edi);
             MacroAssembler::JmpDst addrPosition = m_jit.label();
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJmp(), i + 2 + target));
             MacroAssembler::JmpDst sretTarget = m_jit.label();
@@ -880,7 +880,7 @@ void CTI::privateCompileMainPass()
             break;
         }
         case op_sret: {
-            m_jit.emitJmpN_m(sizeof(Register) * instruction[i + 1].u.operand, MacroAssembler::edi);
+            m_jit.jmp_m(sizeof(Register) * instruction[i + 1].u.operand, MacroAssembler::edi);
             i += 2;
             break;
         }
@@ -892,7 +892,7 @@ void CTI::privateCompileMainPass()
             emitJumpSlowCaseIfNotImm(MacroAssembler::ecx, i);
             emitFastArithImmToInt(MacroAssembler::eax);
             emitFastArithImmToInt(MacroAssembler::ecx);
-            m_jit.emitShll_CLr(MacroAssembler::eax);
+            m_jit.shll_CLr(MacroAssembler::eax);
             emitFastArithIntToImmOrSlowCase(MacroAssembler::eax, i);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -905,17 +905,17 @@ void CTI::privateCompileMainPass()
             if (JSValue* value = getConstantImmediateNumericArg(src1)) {
                 emitGetArg(src2, MacroAssembler::eax);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-                m_jit.emitAndl_i32r(reinterpret_cast<unsigned>(value), MacroAssembler::eax); // FIXME: make it more obvious this is relying on the format of JSImmediate
+                m_jit.andl_i32r(reinterpret_cast<unsigned>(value), MacroAssembler::eax); // FIXME: make it more obvious this is relying on the format of JSImmediate
                 emitPutResult(dst);
             } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
                 emitGetArg(src1, MacroAssembler::eax);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-                m_jit.emitAndl_i32r(reinterpret_cast<unsigned>(value), MacroAssembler::eax);
+                m_jit.andl_i32r(reinterpret_cast<unsigned>(value), MacroAssembler::eax);
                 emitPutResult(dst);
             } else {
                 emitGetArg(src1, MacroAssembler::eax);
                 emitGetArg(src2, MacroAssembler::edx);
-                m_jit.emitAndl_rr(MacroAssembler::edx, MacroAssembler::eax);
+                m_jit.andl_rr(MacroAssembler::edx, MacroAssembler::eax);
                 emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
                 emitPutResult(dst);
             }
@@ -928,7 +928,7 @@ void CTI::privateCompileMainPass()
             emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
             emitJumpSlowCaseIfNotImm(MacroAssembler::ecx, i);
             emitFastArithImmToInt(MacroAssembler::ecx);
-            m_jit.emitSarl_CLr(MacroAssembler::eax);
+            m_jit.sarl_CLr(MacroAssembler::eax);
             emitFastArithPotentiallyReTagImmediate(MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -937,7 +937,7 @@ void CTI::privateCompileMainPass()
         case op_bitnot: {
             emitGetArg(instruction[i + 2].u.operand, MacroAssembler::eax);
             emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-            m_jit.emitXorl_i8r(~JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
+            m_jit.xorl_i8r(~JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -968,10 +968,10 @@ void CTI::privateCompileMainPass()
             emitFastArithDeTagImmediate(MacroAssembler::eax);
             emitFastArithDeTagImmediate(MacroAssembler::ecx);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJe(), i)); // This is checking if the last detag resulted in a value 0.
-            m_jit.emitCdq();
-            m_jit.emitIdivl_r(MacroAssembler::ecx);
+            m_jit.cdq();
+            m_jit.idivl_r(MacroAssembler::ecx);
             emitFastArithReTagImmediate(MacroAssembler::edx);
-            m_jit.emitMovl_rr(MacroAssembler::edx, MacroAssembler::eax);
+            m_jit.movl_rr(MacroAssembler::edx, MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -980,14 +980,14 @@ void CTI::privateCompileMainPass()
             unsigned target = instruction[i + 2].u.operand;
             emitGetArg(instruction[i + 1].u.operand, MacroAssembler::eax);
 
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), MacroAssembler::eax);
             MacroAssembler::JmpSrc isZero = m_jit.emitUnlinkedJe();
-            m_jit.emitTestl_i32r(JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
+            m_jit.testl_i32r(JSImmediate::TagBitTypeInteger, MacroAssembler::eax);
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJne(), i + 2 + target));
 
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::trueImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::trueImmediate()), MacroAssembler::eax);
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJe(), i + 2 + target));
-            m_jit.emitCmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::falseImmediate()), MacroAssembler::eax);
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::falseImmediate()), MacroAssembler::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
 
             m_jit.link(isZero, m_jit.label());
@@ -999,9 +999,9 @@ void CTI::privateCompileMainPass()
         case op_post_dec: {
             int srcDst = instruction[i + 2].u.operand;
             emitGetArg(srcDst, MacroAssembler::eax);
-            m_jit.emitMovl_rr(MacroAssembler::eax, MacroAssembler::edx);
+            m_jit.movl_rr(MacroAssembler::eax, MacroAssembler::edx);
             emitJumpSlowCaseIfNotImm(MacroAssembler::eax, i);
-            m_jit.emitSubl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::edx);
+            m_jit.subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::edx);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
             emitPutResult(srcDst, MacroAssembler::edx);
             emitPutResult(instruction[i + 1].u.operand);
@@ -1013,7 +1013,7 @@ void CTI::privateCompileMainPass()
             emitGetArg(instruction[i + 2].u.operand, MacroAssembler::eax);
             emitGetArg(instruction[i + 3].u.operand, MacroAssembler::edx);
             emitJumpSlowCaseIfNotImms(MacroAssembler::eax, MacroAssembler::edx, i);
-            m_jit.emitXorl_rr(MacroAssembler::edx, MacroAssembler::eax);
+            m_jit.xorl_rr(MacroAssembler::edx, MacroAssembler::eax);
             emitFastArithReTagImmediate(MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -1031,7 +1031,7 @@ void CTI::privateCompileMainPass()
             emitGetArg(instruction[i + 2].u.operand, MacroAssembler::eax);
             emitGetArg(instruction[i + 3].u.operand, MacroAssembler::edx);
             emitJumpSlowCaseIfNotImms(MacroAssembler::eax, MacroAssembler::edx, i);
-            m_jit.emitOrl_rr(MacroAssembler::edx, MacroAssembler::eax);
+            m_jit.orl_rr(MacroAssembler::edx, MacroAssembler::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1044,10 +1044,10 @@ void CTI::privateCompileMainPass()
         case op_throw: {
             emitGetPutArg(instruction[i + 1].u.operand, 0, MacroAssembler::ecx);
             emitCall(i, Machine::cti_op_throw);
-            m_jit.emitAddl_i8r(0x24, MacroAssembler::esp);
-            m_jit.emitPopl_r(MacroAssembler::edi);
-            m_jit.emitPopl_r(MacroAssembler::esi);
-            m_jit.emitRet();
+            m_jit.addl_i8r(0x24, MacroAssembler::esp);
+            m_jit.popl_r(MacroAssembler::edi);
+            m_jit.popl_r(MacroAssembler::esi);
+            m_jit.ret();
             i += 2;
             break;
         }
@@ -1062,7 +1062,7 @@ void CTI::privateCompileMainPass()
             emitGetPutArg(instruction[i + 2].u.operand, 0, MacroAssembler::ecx);
             unsigned target = instruction[i + 3].u.operand;
             emitCall(i, Machine::cti_op_next_pname);
-            m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
             MacroAssembler::JmpSrc endOfIter = m_jit.emitUnlinkedJe();
             emitPutResult(instruction[i + 1].u.operand);
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJmp(), i + 3 + target));
@@ -1117,8 +1117,8 @@ void CTI::privateCompileMainPass()
         case op_catch: {
             emitGetCTIParam(CTI_ARGS_r, MacroAssembler::edi); // edi := r
             emitGetCTIParam(CTI_ARGS_exec, MacroAssembler::ecx);
-            m_jit.emitMovl_mr(OBJECT_OFFSET(ExecState, m_exception), MacroAssembler::ecx, MacroAssembler::eax);
-            m_jit.emitMovl_i32m(0, OBJECT_OFFSET(ExecState, m_exception), MacroAssembler::ecx);
+            m_jit.movl_mr(OBJECT_OFFSET(ExecState, m_exception), MacroAssembler::ecx, MacroAssembler::eax);
+            m_jit.movl_i32m(0, OBJECT_OFFSET(ExecState, m_exception), MacroAssembler::ecx);
             emitPutResult(instruction[i + 1].u.operand);
             i += 2;
             break;
@@ -1153,7 +1153,7 @@ void CTI::privateCompileMainPass()
             emitGetPutArg(scrutinee, 0, MacroAssembler::ecx);
             emitPutArgConstant(tableIndex, 4);
             emitCall(i, Machine::cti_op_switch_imm);
-            m_jit.emitJmpN_r(MacroAssembler::eax);
+            m_jit.jmp_r(MacroAssembler::eax);
             i += 4;
             break;
         }
@@ -1170,7 +1170,7 @@ void CTI::privateCompileMainPass()
             emitGetPutArg(scrutinee, 0, MacroAssembler::ecx);
             emitPutArgConstant(tableIndex, 4);
             emitCall(i, Machine::cti_op_switch_char);
-            m_jit.emitJmpN_r(MacroAssembler::eax);
+            m_jit.jmp_r(MacroAssembler::eax);
             i += 4;
             break;
         }
@@ -1186,7 +1186,7 @@ void CTI::privateCompileMainPass()
             emitGetPutArg(scrutinee, 0, MacroAssembler::ecx);
             emitPutArgConstant(tableIndex, 4);
             emitCall(i, Machine::cti_op_switch_string);
-            m_jit.emitJmpN_r(MacroAssembler::eax);
+            m_jit.jmp_r(MacroAssembler::eax);
             i += 4;
             break;
         }
@@ -1285,7 +1285,7 @@ void CTI::privateCompileSlowCases()
                 if (JSImmediate::isNumber(value)) {
                     MacroAssembler::JmpSrc notImm = iter->from;
                     m_jit.link((++iter)->from, m_jit.label());
-                    m_jit.emitSubl_i32r(getDeTaggedConstantImmediate(value), MacroAssembler::eax);
+                    m_jit.subl_i32r(getDeTaggedConstantImmediate(value), MacroAssembler::eax);
                     m_jit.link(notImm, m_jit.label());
                     emitPutArg(MacroAssembler::eax, 0);
                     emitGetPutArg(src2, 4, MacroAssembler::ecx);
@@ -1300,7 +1300,7 @@ void CTI::privateCompileSlowCases()
 
             MacroAssembler::JmpSrc notImm = iter->from;
             m_jit.link((++iter)->from, m_jit.label());
-            m_jit.emitSubl_rr(MacroAssembler::edx, MacroAssembler::eax);
+            m_jit.subl_rr(MacroAssembler::edx, MacroAssembler::eax);
             emitFastArithReTagImmediate(MacroAssembler::eax);
             m_jit.link(notImm, m_jit.label());
             emitPutArg(MacroAssembler::eax, 0);
@@ -1327,7 +1327,7 @@ void CTI::privateCompileSlowCases()
         case op_sub: {
             MacroAssembler::JmpSrc notImm = iter->from;
             m_jit.link((++iter)->from, m_jit.label());
-            m_jit.emitAddl_rr(MacroAssembler::edx, MacroAssembler::eax);
+            m_jit.addl_rr(MacroAssembler::edx, MacroAssembler::eax);
             m_jit.link(notImm, m_jit.label());
             emitPutArg(MacroAssembler::eax, 0);
             emitPutArg(MacroAssembler::edx, 4);
@@ -1371,7 +1371,7 @@ void CTI::privateCompileSlowCases()
                 emitPutArg(MacroAssembler::edx, 0);
                 emitGetPutArg(instruction[i + 2].u.operand, 4, MacroAssembler::ecx);
                 emitCall(i, Machine::cti_op_loop_if_less);
-                m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+                m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
             } else {
                 m_jit.link(iter->from, m_jit.label());
@@ -1379,7 +1379,7 @@ void CTI::privateCompileSlowCases()
                 emitPutArg(MacroAssembler::eax, 0);
                 emitPutArg(MacroAssembler::edx, 4);
                 emitCall(i, Machine::cti_op_loop_if_less);
-                m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+                m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
             }
             i += 4;
@@ -1389,7 +1389,7 @@ void CTI::privateCompileSlowCases()
             unsigned srcDst = instruction[i + 1].u.operand;
             MacroAssembler::JmpSrc notImm = iter->from;
             m_jit.link((++iter)->from, m_jit.label());
-            m_jit.emitSubl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
+            m_jit.subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
             m_jit.link(notImm, m_jit.label());
             emitPutArg(MacroAssembler::eax, 0);
             emitCall(i, Machine::cti_op_pre_inc);
@@ -1417,7 +1417,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             emitPutArg(MacroAssembler::eax, 0);
             emitCall(i, Machine::cti_op_jtrue);
-            m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
             unsigned target = instruction[i + 2].u.operand;
             m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 2 + target]);
             i += 3;
@@ -1427,7 +1427,7 @@ void CTI::privateCompileSlowCases()
             unsigned srcDst = instruction[i + 1].u.operand;
             MacroAssembler::JmpSrc notImm = iter->from;
             m_jit.link((++iter)->from, m_jit.label());
-            m_jit.emitAddl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
+            m_jit.addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), MacroAssembler::eax);
             m_jit.link(notImm, m_jit.label());
             emitPutArg(MacroAssembler::eax, 0);
             emitCall(i, Machine::cti_op_pre_dec);
@@ -1443,7 +1443,7 @@ void CTI::privateCompileSlowCases()
                 emitPutArg(MacroAssembler::edx, 0);
                 emitGetPutArg(instruction[i + 2].u.operand, 4, MacroAssembler::ecx);
                 emitCall(i, Machine::cti_op_jless);
-                m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+                m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
                 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
             } else {
                 m_jit.link(iter->from, m_jit.label());
@@ -1451,7 +1451,7 @@ void CTI::privateCompileSlowCases()
                 emitPutArg(MacroAssembler::eax, 0);
                 emitPutArg(MacroAssembler::edx, 4);
                 emitCall(i, Machine::cti_op_jless);
-                m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+                m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
                 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
             }
             i += 4;
@@ -1459,7 +1459,7 @@ void CTI::privateCompileSlowCases()
         }
         case op_not: {
             m_jit.link(iter->from, m_jit.label());
-            m_jit.emitXorl_i8r(JSImmediate::FullTagTypeBool, MacroAssembler::eax);
+            m_jit.xorl_i8r(JSImmediate::FullTagTypeBool, MacroAssembler::eax);
             emitPutArg(MacroAssembler::eax, 0);
             emitCall(i, Machine::cti_op_not);
             emitPutResult(instruction[i + 1].u.operand);
@@ -1470,7 +1470,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             emitPutArg(MacroAssembler::eax, 0);
             emitCall(i, Machine::cti_op_jtrue);
-            m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
             unsigned target = instruction[i + 2].u.operand;
             m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 2 + target]); // inverted!
             i += 3;
@@ -1526,7 +1526,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             emitPutArg(MacroAssembler::eax, 0);
             emitCall(i, Machine::cti_op_jtrue);
-            m_jit.emitTestl_rr(MacroAssembler::eax, MacroAssembler::eax);
+            m_jit.testl_rr(MacroAssembler::eax, MacroAssembler::eax);
             unsigned target = instruction[i + 2].u.operand;
             m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 2 + target]);
             i += 3;
@@ -1588,8 +1588,8 @@ void CTI::privateCompileSlowCases()
 
 void CTI::privateCompile()
 {
-    // Could use a emitPopl_m, but would need to offset the following instruction if so.
-    m_jit.emitPopl_r(MacroAssembler::ecx);
+    // Could use a popl_m, but would need to offset the following instruction if so.
+    m_jit.popl_r(MacroAssembler::ecx);
     emitGetCTIParam(CTI_ARGS_r, MacroAssembler::edi); // edi := r
     emitPutToCallFrameHeader(MacroAssembler::ecx, RegisterFile::CTIReturnEIP);
 
@@ -1651,15 +1651,15 @@ void CTI::privateCompile()
 void* CTI::privateCompileGetByIdSelf(StructureID* structureID, size_t cachedOffset)
 {
     // Check eax is an object of the right StructureID.
-    m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+    m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.emitCmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases2 = m_jit.emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
-    m_jit.emitMovl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), MacroAssembler::eax, MacroAssembler::eax);
-    m_jit.emitMovl_mr(cachedOffset * sizeof(JSValue*), MacroAssembler::eax, MacroAssembler::eax);
-    m_jit.emitRet();
+    m_jit.movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.movl_mr(cachedOffset * sizeof(JSValue*), MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.ret();
 
     void* code = m_jit.copy();
     ASSERT(code);
@@ -1678,23 +1678,23 @@ void* CTI::privateCompileGetByIdProto(StructureID* structureID, StructureID* pro
     // referencing the prototype object - let's speculatively load it's table nice and early!)
     JSObject* protoObject = static_cast<JSObject*>(structureID->prototype());
     OwnArrayPtr<JSValue*>* protoPropertyStorage = &protoObject->m_propertyStorage;
-    m_jit.emitMovl_mr(static_cast<void*>(protoPropertyStorage), MacroAssembler::edx);
+    m_jit.movl_mr(static_cast<void*>(protoPropertyStorage), MacroAssembler::edx);
 
     // check eax is an object of the right StructureID.
-    m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+    m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.emitCmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases2 = m_jit.emitUnlinkedJne();
 
     // Check the prototype object's StructureID had not changed.
     StructureID** protoStructureIDAddress = &(protoObject->m_structureID);
-    m_jit.emitCmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructureID), static_cast<void*>(protoStructureIDAddress));
+    m_jit.cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructureID), static_cast<void*>(protoStructureIDAddress));
     MacroAssembler::JmpSrc failureCases3 = m_jit.emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
-    m_jit.emitMovl_mr(cachedOffset * sizeof(JSValue*), MacroAssembler::edx, MacroAssembler::eax);
+    m_jit.movl_mr(cachedOffset * sizeof(JSValue*), MacroAssembler::edx, MacroAssembler::eax);
 
-    m_jit.emitRet();
+    m_jit.ret();
 
     void* code = m_jit.copy();
     ASSERT(code);
@@ -1715,9 +1715,9 @@ void* CTI::privateCompileGetByIdChain(StructureID* structureID, StructureIDChain
     Vector<MacroAssembler::JmpSrc> bucketsOfFail;
 
     // Check eax is an object of the right StructureID.
-    m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+    m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
     bucketsOfFail.append(m_jit.emitUnlinkedJne());
-    m_jit.emitCmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
     bucketsOfFail.append(m_jit.emitUnlinkedJne());
 
     StructureID* currStructureID = structureID;
@@ -1729,15 +1729,15 @@ void* CTI::privateCompileGetByIdChain(StructureID* structureID, StructureIDChain
 
         // Check the prototype object's StructureID had not changed.
         StructureID** protoStructureIDAddress = &(protoObject->m_structureID);
-        m_jit.emitCmpl_i32m(reinterpret_cast<uint32_t>(currStructureID), static_cast<void*>(protoStructureIDAddress));
+        m_jit.cmpl_i32m(reinterpret_cast<uint32_t>(currStructureID), static_cast<void*>(protoStructureIDAddress));
         bucketsOfFail.append(m_jit.emitUnlinkedJne());
     }
     ASSERT(protoObject);
  
     OwnArrayPtr<JSValue*>* protoPropertyStorage = &static_cast<JSObject*>(protoObject)->m_propertyStorage;
-    m_jit.emitMovl_mr(static_cast<void*>(protoPropertyStorage), MacroAssembler::edx);
-    m_jit.emitMovl_mr(cachedOffset * sizeof(JSValue*), MacroAssembler::edx, MacroAssembler::eax);
-    m_jit.emitRet();
+    m_jit.movl_mr(static_cast<void*>(protoPropertyStorage), MacroAssembler::edx);
+    m_jit.movl_mr(cachedOffset * sizeof(JSValue*), MacroAssembler::edx, MacroAssembler::eax);
+    m_jit.ret();
 
     bucketsOfFail.append(m_jit.emitUnlinkedJmp());
 
@@ -1753,15 +1753,15 @@ void* CTI::privateCompileGetByIdChain(StructureID* structureID, StructureIDChain
 void* CTI::privateCompilePutByIdReplace(StructureID* structureID, size_t cachedOffset)
 {
     // check eax is an object of the right StructureID.
-    m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+    m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.emitCmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases2 = m_jit.emitUnlinkedJne();
 
     // checks out okay! - putDirectOffset
-    m_jit.emitMovl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), MacroAssembler::eax, MacroAssembler::eax);
-    m_jit.emitMovl_rm(MacroAssembler::edx, cachedOffset * sizeof(JSValue*), MacroAssembler::eax);
-    m_jit.emitRet();
+    m_jit.movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.movl_rm(MacroAssembler::edx, cachedOffset * sizeof(JSValue*), MacroAssembler::eax);
+    m_jit.ret();
 
     void* code = m_jit.copy();
     ASSERT(code);
@@ -1777,20 +1777,20 @@ void* CTI::privateCompilePutByIdReplace(StructureID* structureID, size_t cachedO
 void* CTI::privateArrayLengthTrampoline()
 {
     // Check eax is an array
-    m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+    m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.emitCmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), MacroAssembler::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases2 = m_jit.emitUnlinkedJne();
 
     // Checks out okay! - get the length from the storage
-    m_jit.emitMovl_mr(OBJECT_OFFSET(JSArray, m_storage), MacroAssembler::eax, MacroAssembler::eax);
-    m_jit.emitMovl_mr(OBJECT_OFFSET(ArrayStorage, m_length), MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.movl_mr(OBJECT_OFFSET(JSArray, m_storage), MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.movl_mr(OBJECT_OFFSET(ArrayStorage, m_length), MacroAssembler::eax, MacroAssembler::eax);
 
-    m_jit.emitAddl_rr(MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.addl_rr(MacroAssembler::eax, MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases3 = m_jit.emitUnlinkedJo();
-    m_jit.emitAddl_i8r(1, MacroAssembler::eax);
+    m_jit.addl_i8r(1, MacroAssembler::eax);
     
-    m_jit.emitRet();
+    m_jit.ret();
 
     void* code = m_jit.copy();
     ASSERT(code);
@@ -1805,20 +1805,20 @@ void* CTI::privateArrayLengthTrampoline()
 void* CTI::privateStringLengthTrampoline()
 {
     // Check eax is a string
-    m_jit.emitTestl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
+    m_jit.testl_i32r(JSImmediate::TagMask, MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.emitCmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsStringVptr), MacroAssembler::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsStringVptr), MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases2 = m_jit.emitUnlinkedJne();
 
     // Checks out okay! - get the length from the Ustring.
-    m_jit.emitMovl_mr(OBJECT_OFFSET(JSString, m_value) + OBJECT_OFFSET(UString, m_rep), MacroAssembler::eax, MacroAssembler::eax);
-    m_jit.emitMovl_mr(OBJECT_OFFSET(UString::Rep, len), MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.movl_mr(OBJECT_OFFSET(JSString, m_value) + OBJECT_OFFSET(UString, m_rep), MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.movl_mr(OBJECT_OFFSET(UString::Rep, len), MacroAssembler::eax, MacroAssembler::eax);
 
-    m_jit.emitAddl_rr(MacroAssembler::eax, MacroAssembler::eax);
+    m_jit.addl_rr(MacroAssembler::eax, MacroAssembler::eax);
     MacroAssembler::JmpSrc failureCases3 = m_jit.emitUnlinkedJo();
-    m_jit.emitAddl_i8r(1, MacroAssembler::eax);
+    m_jit.addl_i8r(1, MacroAssembler::eax);
     
-    m_jit.emitRet();
+    m_jit.ret();
 
     void* code = m_jit.copy();
     ASSERT(code);
@@ -1846,12 +1846,12 @@ void* CTI::compileRegExp(ExecState* exec, const UString& pattern, unsigned* numS
     jit.emitConvertToFastCall();
     // (0) Setup:
     //     Preserve regs & initialize outputRegister.
-    jit.emitPushl_r(WRECGenerator::outputRegister);
-    jit.emitPushl_r(WRECGenerator::currentValueRegister);
+    jit.pushl_r(WRECGenerator::outputRegister);
+    jit.pushl_r(WRECGenerator::currentValueRegister);
     // push pos onto the stack, both to preserve and as a parameter available to parseDisjunction
-    jit.emitPushl_r(WRECGenerator::currentPositionRegister);
+    jit.pushl_r(WRECGenerator::currentPositionRegister);
     // load output pointer
-    jit.emitMovl_mr(16
+    jit.movl_mr(16
 #if COMPILER(MSVC)
                     + 3 * sizeof(void*)
 #endif
@@ -1877,23 +1877,23 @@ void* CTI::compileRegExp(ExecState* exec, const UString& pattern, unsigned* numS
     // (2) Success:
     //     Set return value & pop registers from the stack.
 
-    jit.emitTestl_rr(WRECGenerator::outputRegister, WRECGenerator::outputRegister);
+    jit.testl_rr(WRECGenerator::outputRegister, WRECGenerator::outputRegister);
     WRECGenerator::JmpSrc noOutput = jit.emitUnlinkedJe();
 
-    jit.emitMovl_rm(WRECGenerator::currentPositionRegister, 4, WRECGenerator::outputRegister);
-    jit.emitPopl_r(MacroAssembler::eax);
-    jit.emitMovl_rm(MacroAssembler::eax, WRECGenerator::outputRegister);
-    jit.emitPopl_r(WRECGenerator::currentValueRegister);
-    jit.emitPopl_r(WRECGenerator::outputRegister);
-    jit.emitRet();
+    jit.movl_rm(WRECGenerator::currentPositionRegister, 4, WRECGenerator::outputRegister);
+    jit.popl_r(MacroAssembler::eax);
+    jit.movl_rm(MacroAssembler::eax, WRECGenerator::outputRegister);
+    jit.popl_r(WRECGenerator::currentValueRegister);
+    jit.popl_r(WRECGenerator::outputRegister);
+    jit.ret();
     
     jit.link(noOutput, jit.label());
     
-    jit.emitPopl_r(MacroAssembler::eax);
-    jit.emitMovl_rm(MacroAssembler::eax, WRECGenerator::outputRegister);
-    jit.emitPopl_r(WRECGenerator::currentValueRegister);
-    jit.emitPopl_r(WRECGenerator::outputRegister);
-    jit.emitRet();
+    jit.popl_r(MacroAssembler::eax);
+    jit.movl_rm(MacroAssembler::eax, WRECGenerator::outputRegister);
+    jit.popl_r(WRECGenerator::currentValueRegister);
+    jit.popl_r(WRECGenerator::outputRegister);
+    jit.ret();
 
     // (3) Failure:
     //     All fails link to here.  Progress the start point & if it is within scope, loop.
@@ -1903,18 +1903,18 @@ void* CTI::compileRegExp(ExecState* exec, const UString& pattern, unsigned* numS
         jit.link(failures[i], here);
     failures.clear();
 
-    jit.emitMovl_mr(MacroAssembler::esp, WRECGenerator::currentPositionRegister);
-    jit.emitAddl_i8r(1, WRECGenerator::currentPositionRegister);
-    jit.emitMovl_rm(WRECGenerator::currentPositionRegister, MacroAssembler::esp);
-    jit.emitCmpl_rr(WRECGenerator::lengthRegister, WRECGenerator::currentPositionRegister);
+    jit.movl_mr(MacroAssembler::esp, WRECGenerator::currentPositionRegister);
+    jit.addl_i8r(1, WRECGenerator::currentPositionRegister);
+    jit.movl_rm(WRECGenerator::currentPositionRegister, MacroAssembler::esp);
+    jit.cmpl_rr(WRECGenerator::lengthRegister, WRECGenerator::currentPositionRegister);
     jit.link(jit.emitUnlinkedJle(), nextLabel);
 
-    jit.emitAddl_i8r(4, MacroAssembler::esp);
+    jit.addl_i8r(4, MacroAssembler::esp);
 
-    jit.emitMovl_i32r(-1, MacroAssembler::eax);
-    jit.emitPopl_r(WRECGenerator::currentValueRegister);
-    jit.emitPopl_r(WRECGenerator::outputRegister);
-    jit.emitRet();
+    jit.movl_i32r(-1, MacroAssembler::eax);
+    jit.popl_r(WRECGenerator::currentValueRegister);
+    jit.popl_r(WRECGenerator::outputRegister);
+    jit.ret();
 
     *numSubpatterns_ptr = parser.m_numSubpatterns;
 
index 19b4467..24010d9 100644 (file)
@@ -33,14 +33,14 @@ namespace JSC {
 
 void MacroAssembler::emitConvertToFastCall()
 {
-    emitMovl_mr(4, esp, eax);
-    emitMovl_mr(8, esp, edx);
-    emitMovl_mr(12, esp, ecx);
+    movl_mr(4, esp, eax);
+    movl_mr(8, esp, edx);
+    movl_mr(12, esp, ecx);
 }
 
 void MacroAssembler::emitRestoreArgumentReference()
 {
-    emitMovl_rm(esp, 0, esp);
+    movl_rm(esp, 0, esp);
 }
 
 }
index f98600a..df0a297 100644 (file)
@@ -245,167 +245,167 @@ public:
         m_buffer->putByte(OP_INT3);
     }
     
-    void emitPushl_r(RegisterID reg)
+    void pushl_r(RegisterID reg)
     {
         m_buffer->putByte(OP_PUSH_EAX + reg);
     }
     
-    void emitPushl_m(int offset, RegisterID base)
+    void pushl_m(int offset, RegisterID base)
     {
         m_buffer->putByte(OP_GROUP5_Ev);
         emitModRm_opm(GROUP5_OP_PUSH, base, offset);
     }
     
-    void emitPopl_r(RegisterID reg)
+    void popl_r(RegisterID reg)
     {
         m_buffer->putByte(OP_POP_EAX + reg);
     }
 
-    void emitPopl_m(int offset, RegisterID base)
+    void popl_m(int offset, RegisterID base)
     {
         m_buffer->putByte(OP_GROUP1A_Ev);
         emitModRm_opm(GROUP1A_OP_POP, base, offset);
     }
     
-    void emitMovl_rr(RegisterID src, RegisterID dst)
+    void movl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_MOV_EvGv);
         emitModRm_rr(src, dst);
     }
     
-    void emitAddl_rr(RegisterID src, RegisterID dst)
+    void addl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_ADD_EvGv);
         emitModRm_rr(src, dst);
     }
 
-    void emitAddl_i8r(int imm, RegisterID dst)
+    void addl_i8r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIb);
         emitModRm_opr(GROUP1_OP_ADD, dst);
         m_buffer->putByte(imm);
     }
 
-    void emitAddl_i32r(int imm, RegisterID dst)
+    void addl_i32r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIz);
         emitModRm_opr(GROUP1_OP_ADD, dst);
         m_buffer->putInt(imm);
     }
 
-    void emitAddl_mr(int offset, RegisterID base, RegisterID dst)
+    void addl_mr(int offset, RegisterID base, RegisterID dst)
     {
         m_buffer->putByte(OP_ADD_GvEv);
         emitModRm_rm(dst, base, offset);
     }
 
-    void emitAndl_rr(RegisterID src, RegisterID dst)
+    void andl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_AND_EvGv);
         emitModRm_rr(src, dst);
     }
 
-    void emitAndl_i32r(int imm, RegisterID dst)
+    void andl_i32r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIz);
         emitModRm_opr(GROUP1_OP_AND, dst);
         m_buffer->putInt(imm);
     }
 
-    void emitCmpl_i8r(int imm, RegisterID dst)
+    void cmpl_i8r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIb);
         emitModRm_opr(GROUP1_OP_CMP, dst);
         m_buffer->putByte(imm);
     }
 
-    void emitCmpl_rr(RegisterID src, RegisterID dst)
+    void cmpl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_CMP_EvGv);
         emitModRm_rr(src, dst);
     }
 
-    void emitCmpl_rm(RegisterID src, int offset, RegisterID base)
+    void cmpl_rm(RegisterID src, int offset, RegisterID base)
     {
         m_buffer->putByte(OP_CMP_EvGv);
         emitModRm_rm(src, base, offset);
     }
 
-    void emitCmpl_i32r(int imm, RegisterID dst)
+    void cmpl_i32r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIz);
         emitModRm_opr(GROUP1_OP_CMP, dst);
         m_buffer->putInt(imm);
     }
 
-    void emitCmpl_i32m(int imm, RegisterID dst)
+    void cmpl_i32m(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIz);
         emitModRm_opm(GROUP1_OP_CMP, dst);
         m_buffer->putInt(imm);
     }
 
-    void emitCmpl_i32m(int imm, int offset, RegisterID dst)
+    void cmpl_i32m(int imm, int offset, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIz);
         emitModRm_opm(GROUP1_OP_CMP, dst, offset);
         m_buffer->putInt(imm);
     }
 
-    void emitCmpl_i32m(int imm, void* addr)
+    void cmpl_i32m(int imm, void* addr)
     {
         m_buffer->putByte(OP_GROUP1_EvIz);
         emitModRm_opm(GROUP1_OP_CMP, addr);
         m_buffer->putInt(imm);
     }
 
-    void emitCmpw_rm(RegisterID src, RegisterID base, RegisterID index, int scale)
+    void cmpw_rm(RegisterID src, RegisterID base, RegisterID index, int scale)
     {
         m_buffer->putByte(PRE_OPERAND_SIZE);
         m_buffer->putByte(OP_CMP_EvGv);
         emitModRm_rmsib(src, base, index, scale);
     }
 
-    void emitOrl_rr(RegisterID src, RegisterID dst)
+    void orl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_OR_EvGv);
         emitModRm_rr(src, dst);
     }
 
-    void emitOrl_i8r(int imm, RegisterID dst)
+    void orl_rr(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIb);
         emitModRm_opr(GROUP1_OP_OR, dst);
         m_buffer->putByte(imm);
     }
 
-    void emitSubl_rr(RegisterID src, RegisterID dst)
+    void subl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_SUB_EvGv);
         emitModRm_rr(src, dst);
     }
 
-    void emitSubl_i8r(int imm, RegisterID dst)
+    void subl_i8r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIb);
         emitModRm_opr(GROUP1_OP_SUB, dst);
         m_buffer->putByte(imm);
     }
 
-    void emitSubl_i32r(int imm, RegisterID dst)
+    void subl_i32r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIz);
         emitModRm_opr(GROUP1_OP_SUB, dst);
         m_buffer->putInt(imm);
     }
 
-    void emitSubl_mr(int offset, RegisterID base, RegisterID dst)
+    void subl_mr(int offset, RegisterID base, RegisterID dst)
     {
         m_buffer->putByte(OP_SUB_GvEv);
         emitModRm_rm(dst, base, offset);
     }
 
-    void emitTestl_i32r(int imm, RegisterID dst)
+    void testl_i32r(int imm, RegisterID dst)
     {
         m_buffer->ensureSpace(MAX_INSTRUCTION_SIZE);
         m_buffer->putByteUnchecked(OP_GROUP3_EvIz);
@@ -413,26 +413,26 @@ public:
         m_buffer->putIntUnchecked(imm);
     }
 
-    void emitTestl_rr(RegisterID src, RegisterID dst)
+    void testl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_TEST_EvGv);
         emitModRm_rr(src, dst);
     }
     
-    void emitXorl_i8r(int imm, RegisterID dst)
+    void xorl_i8r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP1_EvIb);
         emitModRm_opr(GROUP1_OP_XOR, dst);
         m_buffer->putByte(imm);
     }
 
-    void emitXorl_rr(RegisterID src, RegisterID dst)
+    void xorl_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_XOR_EvGv);
         emitModRm_rr(src, dst);
     }
 
-    void emitSarl_i8r(int imm, RegisterID dst)
+    void sarl_i8r(int imm, RegisterID dst)
     {
         if (imm == 1) {
             m_buffer->putByte(OP_GROUP2_Ev1);
@@ -444,13 +444,13 @@ public:
         }
     }
 
-    void emitSarl_CLr(RegisterID dst)
+    void sarl_CLr(RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP2_EvCL);
         emitModRm_opr(GROUP2_OP_SAR, dst);
     }
 
-    void emitShl_i8r(int imm, RegisterID dst)
+    void shl_i8r(int imm, RegisterID dst)
     {
         if (imm == 1) {
             m_buffer->putByte(OP_GROUP2_Ev1);
@@ -462,103 +462,103 @@ public:
         }
     }
 
-    void emitShll_CLr(RegisterID dst)
+    void shll_CLr(RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP2_EvCL);
         emitModRm_opr(GROUP2_OP_SHL, dst);
     }
 
-    void emitMull_rr(RegisterID src, RegisterID dst)
+    void mull_rr(RegisterID src, RegisterID dst)
     {
         m_buffer->putByte(OP_2BYTE_ESCAPE);
         m_buffer->putByte(OP2_MUL_GvEv);
         emitModRm_rr(dst, src);
     }
 
-    void emitIdivl_r(RegisterID dst)
+    void idivl_r(RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP3_Ev);
         emitModRm_opr(GROUP3_OP_IDIV, dst);
     }
 
-    void emitCdq()
+    void cdq()
     {
         m_buffer->putByte(OP_CDQ);
     }
 
-    void emitMovl_mr(RegisterID base, RegisterID dst)
+    void movl_mr(RegisterID base, RegisterID dst)
     {
         m_buffer->putByte(OP_MOV_GvEv);
         emitModRm_rm(dst, base);
     }
 
-    void emitMovl_mr(int offset, RegisterID base, RegisterID dst)
+    void movl_mr(int offset, RegisterID base, RegisterID dst)
     {
         m_buffer->ensureSpace(MAX_INSTRUCTION_SIZE);
         m_buffer->putByteUnchecked(OP_MOV_GvEv);
         emitModRm_rm_Unchecked(dst, base, offset);
     }
 
-    void emitMovl_mr(void* addr, RegisterID dst)
+    void movl_mr(void* addr, RegisterID dst)
     {
         m_buffer->putByte(OP_MOV_GvEv);
         emitModRm_rm(dst, addr);
     }
 
-    void emitMovl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
+    void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         m_buffer->putByte(OP_MOV_GvEv);
         emitModRm_rmsib(dst, base, index, scale, offset);
     }
 
-    void emitMovzwl_mr(int offset, RegisterID base, RegisterID dst)
+    void movzwl_mr(int offset, RegisterID base, RegisterID dst)
     {
         m_buffer->putByte(OP_2BYTE_ESCAPE);
         m_buffer->putByte(OP2_MOVZX_GvEw);
         emitModRm_rm(dst, base, offset);
     }
 
-    void emitMovzwl_mr(RegisterID base, RegisterID index, int scale, RegisterID dst)
+    void movzwl_mr(RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         m_buffer->putByte(OP_2BYTE_ESCAPE);
         m_buffer->putByte(OP2_MOVZX_GvEw);
         emitModRm_rmsib(dst, base, index, scale);
     }
 
-    void emitMovzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
+    void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         m_buffer->putByte(OP_2BYTE_ESCAPE);
         m_buffer->putByte(OP2_MOVZX_GvEw);
         emitModRm_rmsib(dst, base, index, scale, offset);
     }
 
-    void emitMovl_rm(RegisterID src, RegisterID base)
+    void movl_rm(RegisterID src, RegisterID base)
     {
         m_buffer->putByte(OP_MOV_EvGv);
         emitModRm_rm(src, base);
     }
 
-    void emitMovl_rm(RegisterID src, int offset, RegisterID base)
+    void movl_rm(RegisterID src, int offset, RegisterID base)
     {
         m_buffer->ensureSpace(MAX_INSTRUCTION_SIZE);
         m_buffer->putByteUnchecked(OP_MOV_EvGv);
         emitModRm_rm_Unchecked(src, base, offset);
     }
     
-    void emitMovl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
+    void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
         m_buffer->putByte(OP_MOV_EvGv);
         emitModRm_rmsib(src, base, index, scale, offset);
     }
     
-    void emitMovl_i32r(int imm, RegisterID dst)
+    void movl_i32r(int imm, RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP11_EvIz);
         emitModRm_opr(GROUP11_MOV, dst);
         m_buffer->putInt(imm);
     }
 
-    void emitMovl_i32m(int imm, int offset, RegisterID base)
+    void movl_i32m(int imm, int offset, RegisterID base)
     {
         m_buffer->ensureSpace(MAX_INSTRUCTION_SIZE);
         m_buffer->putByteUnchecked(OP_GROUP11_EvIz);
@@ -566,37 +566,37 @@ public:
         m_buffer->putIntUnchecked(imm);
     }
 
-    void emitMovl_i32m(int imm, void* addr)
+    void movl_i32m(int imm, void* addr)
     {
         m_buffer->putByte(OP_GROUP11_EvIz);
         emitModRm_opm(GROUP11_MOV, addr);
         m_buffer->putInt(imm);
     }
 
-    void emitLeal_mr(int offset, RegisterID base, RegisterID dst)
+    void leal_mr(int offset, RegisterID base, RegisterID dst)
     {
         m_buffer->putByte(OP_LEA);
         emitModRm_rm(dst, base, offset);
     }
 
-    void emitRet()
+    void ret()
     {
         m_buffer->putByte(OP_RET);
     }
     
-    void emitJmpN_r(RegisterID dst)
+    void jmp_r(RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP5_Ev);
         emitModRm_opr(GROUP5_OP_JMPN, dst);
     }
     
-    void emitJmpN_m(int offset, RegisterID base)
+    void jmp_m(int offset, RegisterID base)
     {
         m_buffer->putByte(OP_GROUP5_Ev);
         emitModRm_opm(GROUP5_OP_JMPN, base, offset);
     }
     
-    void emitCallN_r(RegisterID dst)
+    void call_r(RegisterID dst)
     {
         m_buffer->putByte(OP_GROUP5_Ev);
         emitModRm_opr(GROUP5_OP_CALLN, dst);
index 406fc97..d563074 100644 (file)
@@ -492,21 +492,21 @@ void GenerateParenthesesNonGreedyFunctor::backtrack(WRECGenerator*)
 
 void WRECGenerator::generateBacktrack1()
 {
-    m_jit.emitSubl_i8r(1, currentPositionRegister);
+    m_jit.subl_i8r(1, currentPositionRegister);
 }
 
 void WRECGenerator::generateBacktrackBackreference(unsigned subpatternId)
 {
-    m_jit.emitSubl_mr((2 * subpatternId + 1) * sizeof(int), outputRegister, currentPositionRegister);
-    m_jit.emitAddl_mr((2 * subpatternId) * sizeof(int), outputRegister, currentPositionRegister);
+    m_jit.subl_mr((2 * subpatternId + 1) * sizeof(int), outputRegister, currentPositionRegister);
+    m_jit.addl_mr((2 * subpatternId) * sizeof(int), outputRegister, currentPositionRegister);
 }
 
 void WRECGenerator::generateBackreferenceQuantifier(JmpSrcVector& failures, Quantifier::Type quantifierType, unsigned subpatternId, unsigned min, unsigned max)
 {
     GenerateBackreferenceFunctor functor(subpatternId);
 
-    m_jit.emitMovl_mr((2 * subpatternId) * sizeof(int), outputRegister, currentValueRegister);
-    m_jit.emitCmpl_rm(currentValueRegister, ((2 * subpatternId) + 1) * sizeof(int), outputRegister);
+    m_jit.movl_mr((2 * subpatternId) * sizeof(int), outputRegister, currentValueRegister);
+    m_jit.cmpl_rm(currentValueRegister, ((2 * subpatternId) + 1) * sizeof(int), outputRegister);
     JmpSrc skipIfEmpty = m_jit.emitUnlinkedJe();
 
     ASSERT(quantifierType == Quantifier::Greedy || quantifierType == Quantifier::NonGreedy);
@@ -525,25 +525,25 @@ void WRECGenerator::generateNonGreedyQuantifier(JmpSrcVector& failures, Generate
 
     // (0) Setup:
     //     init quantifierCountRegister
-    m_jit.emitPushl_r(quantifierCountRegister);
-    m_jit.emitXorl_rr(quantifierCountRegister, quantifierCountRegister);
+    m_jit.pushl_r(quantifierCountRegister);
+    m_jit.xorl_rr(quantifierCountRegister, quantifierCountRegister);
     JmpSrc gotoStart = m_jit.emitUnlinkedJmp();
 
     // (4) Failure case
 
     JmpDst quantifierFailed = m_jit.label();
     // (4.1) Restore original value of quantifierCountRegister from the stack
-    m_jit.emitPopl_r(quantifierCountRegister);
+    m_jit.popl_r(quantifierCountRegister);
     failures.append(m_jit.emitUnlinkedJmp()); 
 
     // (3) We just tried an alternative, and it failed - check we can try more.
     
     JmpDst alternativeFailed = m_jit.label();
     // (3.1) remove the value pushed prior to testing the alternative
-    m_jit.emitPopl_r(currentPositionRegister);
+    m_jit.popl_r(currentPositionRegister);
     // (3.2) if there is a limit, and we have reached it, game over. 
     if (max != Quantifier::noMaxSpecified) {
-        m_jit.emitCmpl_i32r(max, quantifierCountRegister);
+        m_jit.cmpl_i32r(max, quantifierCountRegister);
         m_jit.link(m_jit.emitUnlinkedJe(), quantifierFailed);
     }
 
@@ -556,7 +556,7 @@ void WRECGenerator::generateNonGreedyQuantifier(JmpSrcVector& failures, Generate
     // (1.1) Do a check for the atom check.
     functor.generateAtom(this, newFailures);
     // (1.2) If we get here, successful match!
-    m_jit.emitAddl_i8r(1, quantifierCountRegister);
+    m_jit.addl_i8r(1, quantifierCountRegister);
     // (1.3) We needed to read the atom, and we failed - that's terminally  bad news.
     for (unsigned i = 0; i < newFailures.size(); ++i)
         m_jit.link(newFailures[i], quantifierFailed);
@@ -565,7 +565,7 @@ void WRECGenerator::generateNonGreedyQuantifier(JmpSrcVector& failures, Generate
     if (min) {
         // ... except if min was 1 no need to keep checking!
         if (min != 1) {
-            m_jit.emitCmpl_i32r(min, quantifierCountRegister);
+            m_jit.cmpl_i32r(min, quantifierCountRegister);
             m_jit.link(m_jit.emitUnlinkedJl(), testQuantifiedAtom);
         }
     } else
@@ -575,10 +575,10 @@ void WRECGenerator::generateNonGreedyQuantifier(JmpSrcVector& failures, Generate
     // (2) Plant an alternative check for the remainder of the expression
     
     // (2.1) recursively call to parseAlternative, if it falls through, success!
-    m_jit.emitPushl_r(currentPositionRegister);
+    m_jit.pushl_r(currentPositionRegister);
     m_parser.parseAlternative(newFailures);
-    m_jit.emitAddl_i8r(4, X86Assembler::esp);
-    m_jit.emitPopl_r(quantifierCountRegister);
+    m_jit.addl_i8r(4, X86Assembler::esp);
+    m_jit.popl_r(quantifierCountRegister);
     // (2.2) link failure cases to jump back up to alternativeFailed.
     for (unsigned i = 0; i < newFailures.size(); ++i)
         m_jit.link(newFailures[i], alternativeFailed);
@@ -595,8 +595,8 @@ void WRECGenerator::generateGreedyQuantifier(JmpSrcVector& failures, GenerateAto
 
     // (0) Setup:
     //     init quantifierCountRegister
-    m_jit.emitPushl_r(quantifierCountRegister);
-    m_jit.emitXorl_rr(quantifierCountRegister, quantifierCountRegister);
+    m_jit.pushl_r(quantifierCountRegister);
+    m_jit.xorl_rr(quantifierCountRegister, quantifierCountRegister);
 
     // (1) Greedily read as many of the atom as possible
 
@@ -605,12 +605,12 @@ void WRECGenerator::generateGreedyQuantifier(JmpSrcVector& failures, GenerateAto
     // (1.1) Do a character class check.
     functor.generateAtom(this, newFailures);
     // (1.2) If we get here, successful match!
-    m_jit.emitAddl_i8r(1, quantifierCountRegister);
+    m_jit.addl_i8r(1, quantifierCountRegister);
     // (1.3) loop, unless we've read max limit.
     if (max != Quantifier::noMaxSpecified) {
         if (max != 1) {
             // if there is a limit, only loop while less than limit, otherwise fall throught to...
-            m_jit.emitCmpl_i32r(max, quantifierCountRegister);
+            m_jit.cmpl_i32r(max, quantifierCountRegister);
             m_jit.link(m_jit.emitUnlinkedJne(), readMore);
         }
         // ...if there is no min we need jump to the alternative test, if there is we can just fall through to it.
@@ -627,7 +627,7 @@ void WRECGenerator::generateGreedyQuantifier(JmpSrcVector& failures, GenerateAto
             m_jit.link(newFailures[i], minimumTest);
         newFailures.clear();
         // 
-        m_jit.emitCmpl_i32r(min, quantifierCountRegister);
+        m_jit.cmpl_i32r(min, quantifierCountRegister);
         newFailures.append(m_jit.emitUnlinkedJae());
     }
 
@@ -635,20 +635,20 @@ void WRECGenerator::generateGreedyQuantifier(JmpSrcVector& failures, GenerateAto
 
     JmpDst quantifierFailed = m_jit.label();
     // (4.1) Restore original value of quantifierCountRegister from the stack
-    m_jit.emitPopl_r(quantifierCountRegister);
+    m_jit.popl_r(quantifierCountRegister);
     failures.append(m_jit.emitUnlinkedJmp()); 
 
     // (3) Backtrack
 
     JmpDst backtrack = m_jit.label();
     // (3.1) this was preserved prior to executing the alternative
-    m_jit.emitPopl_r(currentPositionRegister);
+    m_jit.popl_r(currentPositionRegister);
     // (3.2) check we can retry with fewer matches - backtracking fails if already at the minimum
-    m_jit.emitCmpl_i32r(min, quantifierCountRegister);
+    m_jit.cmpl_i32r(min, quantifierCountRegister);
     m_jit.link(m_jit.emitUnlinkedJe(), quantifierFailed);
     // (3.3) roll off one match, and retry.
     functor.backtrack(this);
-    m_jit.emitSubl_i8r(1, quantifierCountRegister);
+    m_jit.subl_i8r(1, quantifierCountRegister);
 
     // (2) Try an alternative.
 
@@ -658,10 +658,10 @@ void WRECGenerator::generateGreedyQuantifier(JmpSrcVector& failures, GenerateAto
         m_jit.link(newFailures[i], tryAlternative);
     newFailures.clear();
     // (2.2) recursively call to parseAlternative, if it falls through, success!
-    m_jit.emitPushl_r(currentPositionRegister);
+    m_jit.pushl_r(currentPositionRegister);
     m_parser.parseAlternative(newFailures);
-    m_jit.emitAddl_i8r(4, X86Assembler::esp);
-    m_jit.emitPopl_r(quantifierCountRegister);
+    m_jit.addl_i8r(4, X86Assembler::esp);
+    m_jit.popl_r(quantifierCountRegister);
     // (2.3) link failure cases to here.
     for (unsigned i = 0; i < newFailures.size(); ++i)
         m_jit.link(newFailures[i], backtrack);
@@ -671,9 +671,9 @@ void WRECGenerator::generateGreedyQuantifier(JmpSrcVector& failures, GenerateAto
 void WRECGenerator::generatePatternCharacter(JmpSrcVector& failures, int ch)
 {
     // check there is more input, read a char.
-    m_jit.emitCmpl_rr(lengthRegister, currentPositionRegister);
+    m_jit.cmpl_rr(lengthRegister, currentPositionRegister);
     failures.append(m_jit.emitUnlinkedJe());
-    m_jit.emitMovzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
+    m_jit.movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
 
     // used for unicode case insensitive
     bool hasUpper = false;
@@ -685,11 +685,11 @@ void WRECGenerator::generatePatternCharacter(JmpSrcVector& failures, int ch)
         
         // check for ascii case sensitive characters
         if (isASCIIAlpha(ch)) {
-            m_jit.emitOrl_i8r(32, currentValueRegister);
+            m_jit.orl_rr(32, currentValueRegister);
             ch |= 32;
         } else if ((ch > 0x7f) && ((lower = Unicode::toLower(ch)) != (upper = Unicode::toUpper(ch)))) {
             // handle unicode case sentitive characters - branch to success on upper
-            m_jit.emitCmpl_i32r(upper, currentValueRegister);
+            m_jit.cmpl_i32r(upper, currentValueRegister);
             isUpper = m_jit.emitUnlinkedJe();
             hasUpper = true;
             ch = lower;
@@ -697,7 +697,7 @@ void WRECGenerator::generatePatternCharacter(JmpSrcVector& failures, int ch)
     }
     
     // checks for ch, or lower case version of ch, if insensitive
-    m_jit.emitCmpl_i32r((unsigned short)ch, currentValueRegister);
+    m_jit.cmpl_i32r((unsigned short)ch, currentValueRegister);
     failures.append(m_jit.emitUnlinkedJne());
 
     if (m_parser.m_ignoreCase && hasUpper) {
@@ -706,7 +706,7 @@ void WRECGenerator::generatePatternCharacter(JmpSrcVector& failures, int ch)
     }
     
     // on success consume the char
-    m_jit.emitAddl_i8r(1, currentPositionRegister);
+    m_jit.addl_i8r(1, currentPositionRegister);
 }
 
 void WRECGenerator::generateCharacterClassInvertedRange(JmpSrcVector& failures, JmpSrcVector& matchDest, const CharacterClassRange* ranges, unsigned count, unsigned* matchIndex, const UChar* matches, unsigned matchCount)
@@ -717,7 +717,7 @@ void WRECGenerator::generateCharacterClassInvertedRange(JmpSrcVector& failures,
         char lo = ranges[which].begin;
         char hi = ranges[which].end;
         
-        m_jit.emitCmpl_i32r((unsigned short)lo, currentValueRegister);
+        m_jit.cmpl_i32r((unsigned short)lo, currentValueRegister);
 
         // check if there are any ranges or matches below lo.  If not, just jl to failure -
         // if there is anything else to check, check that first, if it falls through jmp to failure.
@@ -729,7 +729,7 @@ void WRECGenerator::generateCharacterClassInvertedRange(JmpSrcVector& failures,
                 generateCharacterClassInvertedRange(failures, matchDest, ranges, which, matchIndex, matches, matchCount);
             
             do {
-                m_jit.emitCmpl_i32r((unsigned short)matches[*matchIndex], currentValueRegister);
+                m_jit.cmpl_i32r((unsigned short)matches[*matchIndex], currentValueRegister);
                 matchDest.append(m_jit.emitUnlinkedJe());
                 ++*matchIndex;
             } while ((*matchIndex < matchCount) && (matches[*matchIndex] < lo));
@@ -749,7 +749,7 @@ void WRECGenerator::generateCharacterClassInvertedRange(JmpSrcVector& failures,
         while ((*matchIndex < matchCount) && (matches[*matchIndex] <= hi))
             ++*matchIndex;
 
-        m_jit.emitCmpl_i32r((unsigned short)hi, currentValueRegister);
+        m_jit.cmpl_i32r((unsigned short)hi, currentValueRegister);
         matchDest.append(m_jit.emitUnlinkedJle());
         // fall through to here, the value is above hi.
 
@@ -764,13 +764,13 @@ void WRECGenerator::generateCharacterClassInverted(JmpSrcVector& matchDest, Char
 {
     JmpSrc unicodeFail;
     if (charClass.numMatchesUnicode || charClass.numRangesUnicode) {
-        m_jit.emitCmpl_i8r(0x7f, currentValueRegister);
+        m_jit.cmpl_i8r(0x7f, currentValueRegister);
         JmpSrc isAscii = m_jit.emitUnlinkedJle();
     
         if (charClass.numMatchesUnicode) {
             for (unsigned i = 0; i < charClass.numMatchesUnicode; ++i) {
                 UChar ch = charClass.matchesUnicode[i];
-                m_jit.emitCmpl_i32r((unsigned short)ch, currentValueRegister);
+                m_jit.cmpl_i32r((unsigned short)ch, currentValueRegister);
                 matchDest.append(m_jit.emitUnlinkedJe());
             }
         }
@@ -780,9 +780,9 @@ void WRECGenerator::generateCharacterClassInverted(JmpSrcVector& matchDest, Char
                 UChar lo = charClass.rangesUnicode[i].begin;
                 UChar hi = charClass.rangesUnicode[i].end;
                 
-                m_jit.emitCmpl_i32r((unsigned short)lo, currentValueRegister);
+                m_jit.cmpl_i32r((unsigned short)lo, currentValueRegister);
                 JmpSrc below = m_jit.emitUnlinkedJl();
-                m_jit.emitCmpl_i32r((unsigned short)hi, currentValueRegister);
+                m_jit.cmpl_i32r((unsigned short)hi, currentValueRegister);
                 matchDest.append(m_jit.emitUnlinkedJle());
                 m_jit.link(below, m_jit.label());
             }
@@ -797,7 +797,7 @@ void WRECGenerator::generateCharacterClassInverted(JmpSrcVector& matchDest, Char
         JmpSrcVector failures; 
         generateCharacterClassInvertedRange(failures, matchDest, charClass.ranges, charClass.numRanges, &matchIndex, charClass.matches, charClass.numMatches);
         while (matchIndex < charClass.numMatches) {
-            m_jit.emitCmpl_i32r((unsigned short)charClass.matches[matchIndex], currentValueRegister);
+            m_jit.cmpl_i32r((unsigned short)charClass.matches[matchIndex], currentValueRegister);
             matchDest.append(m_jit.emitUnlinkedJe());
             ++matchIndex;
         }
@@ -819,16 +819,16 @@ void WRECGenerator::generateCharacterClassInverted(JmpSrcVector& matchDest, Char
                 if (isASCIIUpper(ch))
                     continue;
             }
-            m_jit.emitCmpl_i32r((unsigned short)ch, currentValueRegister);
+            m_jit.cmpl_i32r((unsigned short)ch, currentValueRegister);
             matchDest.append(m_jit.emitUnlinkedJe());
         }
 
         if (unsigned countAZaz = matchesAZaz.size()) {
-            m_jit.emitOrl_i8r(32, currentValueRegister);
+            m_jit.orl_rr(32, currentValueRegister);
 
             for (unsigned i = 0; i < countAZaz; ++i) {
                 char ch = matchesAZaz[i];
-                m_jit.emitCmpl_i32r((unsigned short)ch, currentValueRegister);
+                m_jit.cmpl_i32r((unsigned short)ch, currentValueRegister);
                 matchDest.append(m_jit.emitUnlinkedJe());
             }
         }
@@ -840,9 +840,9 @@ void WRECGenerator::generateCharacterClassInverted(JmpSrcVector& matchDest, Char
 
 void WRECGenerator::generateCharacterClass(JmpSrcVector& failures, CharacterClass& charClass, bool invert)
 {
-    m_jit.emitCmpl_rr(lengthRegister, currentPositionRegister);
+    m_jit.cmpl_rr(lengthRegister, currentPositionRegister);
     failures.append(m_jit.emitUnlinkedJe());
-    m_jit.emitMovzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
+    m_jit.movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
 
     if (invert)
         generateCharacterClassInverted(failures, charClass);
@@ -855,7 +855,7 @@ void WRECGenerator::generateCharacterClass(JmpSrcVector& failures, CharacterClas
             m_jit.link(successes[i], here);
     }
     
-    m_jit.emitAddl_i8r(1, currentPositionRegister);
+    m_jit.addl_i8r(1, currentPositionRegister);
 }
 
 WRECGenerator::JmpSrc WRECGenerator::generateParentheses(ParenthesesType type)
@@ -863,20 +863,20 @@ WRECGenerator::JmpSrc WRECGenerator::generateParentheses(ParenthesesType type)
     unsigned subpatternId = (type == capturing) ? ++m_parser.m_numSubpatterns : m_parser.m_numSubpatterns;
 
     // push pos, both to preserve for fail + reloaded in parseDisjunction
-    m_jit.emitPushl_r(currentPositionRegister);
+    m_jit.pushl_r(currentPositionRegister);
 
     // Plant a disjunction, wrapped to invert behaviour - 
     JmpSrcVector newFailures;
     m_parser.parseDisjunction(newFailures);
     
     if (type == capturing) {
-        m_jit.emitPopl_r(currentValueRegister);
-        m_jit.emitMovl_rm(currentValueRegister, (2 * subpatternId) * sizeof(int), outputRegister);
-        m_jit.emitMovl_rm(currentPositionRegister, (2 * subpatternId + 1) * sizeof(int), outputRegister);
+        m_jit.popl_r(currentValueRegister);
+        m_jit.movl_rm(currentValueRegister, (2 * subpatternId) * sizeof(int), outputRegister);
+        m_jit.movl_rm(currentPositionRegister, (2 * subpatternId + 1) * sizeof(int), outputRegister);
     } else if (type == non_capturing)
-        m_jit.emitAddl_i8r(4, X86Assembler::esp);
+        m_jit.addl_i8r(4, X86Assembler::esp);
     else
-        m_jit.emitPopl_r(currentPositionRegister);
+        m_jit.popl_r(currentPositionRegister);
 
     // This is a little lame - jump to jump if there is a nested disjunction.
     // (suggestion to fix: make parseDisjunction populate a JmpSrcVector of
@@ -889,7 +889,7 @@ WRECGenerator::JmpSrc WRECGenerator::generateParentheses(ParenthesesType type)
         m_jit.link(newFailures[i], originalFailure);
     newFailures.clear();
     // fail: restore currentPositionRegister
-    m_jit.emitPopl_r(currentPositionRegister);
+    m_jit.popl_r(currentPositionRegister);
 
     JmpSrc jumpToFail;
     // If this was an inverted assert, fail = success! - just let the failure case drop through,
@@ -922,8 +922,8 @@ WRECGenerator::JmpSrc WRECGenerator::gererateParenthesesResetTrampoline(JmpSrcVe
         m_jit.link(newFailures[i], subPatternResetTrampoline);
     newFailures.clear();
     for (unsigned i = subpatternIdBefore + 1; i <= subpatternIdAfter; ++i) {
-        m_jit.emitMovl_i32m(-1, (2 * i) * sizeof(int), outputRegister);
-        m_jit.emitMovl_i32m(-1, (2 * i + 1) * sizeof(int), outputRegister);
+        m_jit.movl_i32m(-1, (2 * i) * sizeof(int), outputRegister);
+        m_jit.movl_i32m(-1, (2 * i + 1) * sizeof(int), outputRegister);
     }
     
     JmpSrc newFailJump = m_jit.emitUnlinkedJmp();
@@ -938,11 +938,11 @@ void WRECGenerator::generateAssertionBOL(JmpSrcVector& failures)
         JmpSrcVector previousIsNewline;
 
         // begin of input == success
-        m_jit.emitCmpl_i8r(0, currentPositionRegister);
+        m_jit.cmpl_i8r(0, currentPositionRegister);
         previousIsNewline.append(m_jit.emitUnlinkedJe());
 
         // now check prev char against newline characters.
-        m_jit.emitMovzwl_mr(-2, inputRegister, currentPositionRegister, 2, currentValueRegister);
+        m_jit.movzwl_mr(-2, inputRegister, currentPositionRegister, 2, currentValueRegister);
         generateCharacterClassInverted(previousIsNewline, getCharacterClassNewline());
 
         failures.append(m_jit.emitUnlinkedJmp());
@@ -952,7 +952,7 @@ void WRECGenerator::generateAssertionBOL(JmpSrcVector& failures)
             m_jit.link(previousIsNewline[i], success);
         previousIsNewline.clear();
     } else {
-        m_jit.emitCmpl_i8r(0, currentPositionRegister);
+        m_jit.cmpl_i8r(0, currentPositionRegister);
         failures.append(m_jit.emitUnlinkedJne());
     }
 }
@@ -963,11 +963,11 @@ void WRECGenerator::generateAssertionEOL(JmpSrcVector& failures)
         JmpSrcVector nextIsNewline;
 
         // end of input == success
-        m_jit.emitCmpl_rr(lengthRegister, currentPositionRegister);
+        m_jit.cmpl_rr(lengthRegister, currentPositionRegister);
         nextIsNewline.append(m_jit.emitUnlinkedJe());
 
         // now check next char against newline characters.
-        m_jit.emitMovzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
+        m_jit.movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
         generateCharacterClassInverted(nextIsNewline, getCharacterClassNewline());
 
         failures.append(m_jit.emitUnlinkedJmp());
@@ -977,7 +977,7 @@ void WRECGenerator::generateAssertionEOL(JmpSrcVector& failures)
             m_jit.link(nextIsNewline[i], success);
         nextIsNewline.clear();
     } else {
-        m_jit.emitCmpl_rr(lengthRegister, currentPositionRegister);
+        m_jit.cmpl_rr(lengthRegister, currentPositionRegister);
         failures.append(m_jit.emitUnlinkedJne());
     }
 }
@@ -990,10 +990,10 @@ void WRECGenerator::generateAssertionWordBoundary(JmpSrcVector& failures, bool i
     // (1) Check if the previous value was a word char
 
     // (1.1) check for begin of input
-    m_jit.emitCmpl_i8r(0, currentPositionRegister);
+    m_jit.cmpl_i8r(0, currentPositionRegister);
     JmpSrc atBegin = m_jit.emitUnlinkedJe();
     // (1.2) load the last char, and chck if is word character
-    m_jit.emitMovzwl_mr(-2, inputRegister, currentPositionRegister, 2, currentValueRegister);
+    m_jit.movzwl_mr(-2, inputRegister, currentPositionRegister, 2, currentValueRegister);
     JmpSrcVector previousIsWord;
     generateCharacterClassInverted(previousIsWord, getCharacterClassWordchar());
     // (1.3) if we get here, previous is not a word char
@@ -1002,10 +1002,10 @@ void WRECGenerator::generateAssertionWordBoundary(JmpSrcVector& failures, bool i
     // (2) Handle situation where previous was NOT a \w
 
     // (2.1) check for end of input
-    m_jit.emitCmpl_rr(lengthRegister, currentPositionRegister);
+    m_jit.cmpl_rr(lengthRegister, currentPositionRegister);
     notWordBoundary.append(m_jit.emitUnlinkedJe());
     // (2.2) load the next char, and chck if is word character
-    m_jit.emitMovzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
+    m_jit.movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
     generateCharacterClassInverted(wordBoundary, getCharacterClassWordchar());
     // (2.3) If we get here, neither chars are word chars
     notWordBoundary.append(m_jit.emitUnlinkedJmp());
@@ -1018,10 +1018,10 @@ void WRECGenerator::generateAssertionWordBoundary(JmpSrcVector& failures, bool i
         m_jit.link(previousIsWord[i], section3);
     previousIsWord.clear();
     // (3.1) check for end of input
-    m_jit.emitCmpl_rr(lengthRegister, currentPositionRegister);
+    m_jit.cmpl_rr(lengthRegister, currentPositionRegister);
     wordBoundary.append(m_jit.emitUnlinkedJe());
     // (3.2) load the next char, and chck if is word character
-    m_jit.emitMovzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
+    m_jit.movzwl_mr(inputRegister, currentPositionRegister, 2, currentValueRegister);
     generateCharacterClassInverted(notWordBoundary, getCharacterClassWordchar());
     // (3.3) If we get here, this is an end of a word, within the input.
     
@@ -1051,41 +1051,41 @@ void WRECGenerator::generateAssertionWordBoundary(JmpSrcVector& failures, bool i
 
 void WRECGenerator::generateBackreference(JmpSrcVector& failures, unsigned subpatternId)
 {
-    m_jit.emitPushl_r(currentPositionRegister);
-    m_jit.emitPushl_r(quantifierCountRegister);
+    m_jit.pushl_r(currentPositionRegister);
+    m_jit.pushl_r(quantifierCountRegister);
 
     // get the start pos of the backref into quantifierCountRegister (multipurpose!)
-    m_jit.emitMovl_mr((2 * subpatternId) * sizeof(int), outputRegister, quantifierCountRegister);
+    m_jit.movl_mr((2 * subpatternId) * sizeof(int), outputRegister, quantifierCountRegister);
 
     JmpSrc skipIncrement = m_jit.emitUnlinkedJmp();
     JmpDst topOfLoop = m_jit.label();
-    m_jit.emitAddl_i8r(1, currentPositionRegister);
-    m_jit.emitAddl_i8r(1, quantifierCountRegister);
+    m_jit.addl_i8r(1, currentPositionRegister);
+    m_jit.addl_i8r(1, quantifierCountRegister);
     m_jit.link(skipIncrement, m_jit.label());
 
     // check if we're at the end of backref (if we are, success!)
-    m_jit.emitCmpl_rm(quantifierCountRegister, ((2 * subpatternId) + 1) * sizeof(int), outputRegister);
+    m_jit.cmpl_rm(quantifierCountRegister, ((2 * subpatternId) + 1) * sizeof(int), outputRegister);
     JmpSrc endOfBackRef = m_jit.emitUnlinkedJe();
     
-    m_jit.emitMovzwl_mr(inputRegister, quantifierCountRegister, 2, currentValueRegister);
+    m_jit.movzwl_mr(inputRegister, quantifierCountRegister, 2, currentValueRegister);
     
     // check if we've run out of input (this would be a can o'fail)
-    m_jit.emitCmpl_rr(lengthRegister, currentPositionRegister);
+    m_jit.cmpl_rr(lengthRegister, currentPositionRegister);
     JmpSrc endOfInput = m_jit.emitUnlinkedJe();
     
-    m_jit.emitCmpw_rm(currentValueRegister, inputRegister, currentPositionRegister, 2);
+    m_jit.cmpw_rm(currentValueRegister, inputRegister, currentPositionRegister, 2);
     m_jit.link(m_jit.emitUnlinkedJe(), topOfLoop);
     
     m_jit.link(endOfInput, m_jit.label());
     // Failure
-    m_jit.emitPopl_r(quantifierCountRegister);
-    m_jit.emitPopl_r(currentPositionRegister);
+    m_jit.popl_r(quantifierCountRegister);
+    m_jit.popl_r(currentPositionRegister);
     failures.append(m_jit.emitUnlinkedJmp());
     
     // Success
     m_jit.link(endOfBackRef, m_jit.label());
-    m_jit.emitPopl_r(quantifierCountRegister);
-    m_jit.emitAddl_i8r(4, X86Assembler::esp);
+    m_jit.popl_r(quantifierCountRegister);
+    m_jit.addl_i8r(4, X86Assembler::esp);
 }
 
 void WRECGenerator::gernerateDisjunction(JmpSrcVector& successes, JmpSrcVector& failures)
@@ -1098,7 +1098,7 @@ void WRECGenerator::gernerateDisjunction(JmpSrcVector& successes, JmpSrcVector&
         m_jit.link(failures[i], here);
     failures.clear();
     
-    m_jit.emitMovl_mr(X86Assembler::esp, currentPositionRegister);
+    m_jit.movl_mr(X86Assembler::esp, currentPositionRegister);
 }
 
 void WRECGenerator::terminateDisjunction(JmpSrcVector& successes)