Changeset 39261 in webkit for trunk/JavaScriptCore/jit

Timestamp:

Dec 12, 2008, 5:39:38 PM (16 years ago)

Author:

[email protected]

Message:

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

Reviewed by Geoff Garen.

Move slow-cases of JIT code generation over to the MacroAssembler interface.

• assembler/MacroAssembler.h: (JSC::MacroAssembler::Label::Label): (JSC::MacroAssembler::jae32): (JSC::MacroAssembler::jg32): (JSC::MacroAssembler::jzPtr):
• jit/JIT.cpp: (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompile): (JSC::JIT::emitGetVariableObjectRegister): (JSC::JIT::emitPutVariableObjectRegister):
• jit/JIT.h: (JSC::SlowCaseEntry::SlowCaseEntry): (JSC::JIT::getSlowCase): (JSC::JIT::linkSlowCase):
• jit/JITArithmetic.cpp: (JSC::JIT::compileBinaryArithOpSlowCase):
• jit/JITCall.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase):
• jit/JITInlineMethods.h: (JSC::JIT::emitJumpSlowCaseIfNotJSCell): (JSC::JIT::linkSlowCaseIfNotJSCell):
• jit/JITPropertyAccess.cpp: (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compilePutByIdHotPath): (JSC::JIT::compileGetByIdSlowCase): (JSC::JIT::compilePutByIdSlowCase):

Location:

trunk/JavaScriptCore/jit

Files:

• JIT.cpp (modified) (44 diffs)
• JIT.h (modified) (2 diffs)
• JITArithmetic.cpp (modified) (1 diff)
• JITCall.cpp (modified) (9 diffs)
• JITInlineMethods.h (modified) (1 diff)
• JITPropertyAccess.cpp (modified) (6 diffs)

trunk/JavaScriptCore/jit/JIT.cpp

@@ -1367 +1367 @@
 }
 
-#define CTI_COMPILE_BINARY_OP_SLOW_CASE(name) \
-    case name: { \
-        __ link(iter->from, __ label()); \
-        emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
-        emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(i, Interpreter::cti_##name); \
-        emitPutVirtualRegister(instruction[i + 1].u.operand); \
-        i += 4; \
-        break; \
-    }
-    
 void JIT::privateCompileSlowCases()
 {
@@ -1384 +1373 @@
 
     Instruction* instruction = m_codeBlock->instructions().begin();
-    for (Vector<SlowCaseEntry>::iterator iter = m_slowCases.begin(); iter != m_slowCases.end(); ++iter) {
+    for (Vector<SlowCaseEntry>::iterator iter = m_slowCases.begin(); iter != m_slowCases.end();) {
         // FIXME: enable peephole optimizations for slow cases when applicable
         killLastResultRegister();
@@ -1395 +1384 @@
         switch (OpcodeID opcodeID = m_interpreter->getOpcodeID(instruction[i].u.opcode)) {
         case op_convert_this: {
-            __ link(iter->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_convert_this);
@@ -1408 +1397 @@
             unsigned src2 = instruction[i + 3].u.operand;
             if (JSValue* value = getConstantImmediateNumericArg(src1)) {
-                JmpSrc notImm = iter->from;
-                __ link((++iter)->from, __ label());
-                __ subl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
-                __ link(notImm, __ label());
+                Jump notImm = getSlowCase(iter);
+                linkSlowCase(iter);
+                sub32(Imm32(getDeTaggedConstantImmediate(value)), X86::eax);
+                notImm.link(this);
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::eax, 4);
@@ -1417 +1406 @@
                 emitPutVirtualRegister(dst);
             } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
-                JmpSrc notImm = iter->from;
-                __ link((++iter)->from, __ label());
-                __ subl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
-                __ link(notImm, __ label());
+                Jump notImm = getSlowCase(iter);
+                linkSlowCase(iter);
+                sub32(Imm32(getDeTaggedConstantImmediate(value)), X86::eax);
+                notImm.link(this);
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
@@ -1427 +1416 @@
             } else {
                 OperandTypes types = OperandTypes::fromInt(instruction[i + 4].u.operand);
-                if (types.first().mightBeNumber() && types.second().mightBeNumber())
-                    compileBinaryArithOpSlowCase(op_add, iter, dst, src1, src2, types, i);
-                else
-                    ASSERT_NOT_REACHED();
+                ASSERT(types.first().mightBeNumber() && types.second().mightBeNumber());
+                compileBinaryArithOpSlowCase(op_add, iter, dst, src1, src2, types, i);
             }
 
@@ -1437 +1424 @@
         }
         case op_construct_verify: {
-            __ link(iter->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitGetVirtualRegister(instruction[i + 2].u.operand, X86::eax, i);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
@@ -1447 +1434 @@
         case op_get_by_val: {
             // The slow case that handles accesses to arrays (below) may jump back up to here. 
-            JmpDst beginGetByValSlow = __ label();
-
-            JmpSrc notImm = iter->from;
-            __ link((++iter)->from, __ label());
-            __ link((++iter)->from, __ label());
+            Label beginGetByValSlow(this);
+
+            Jump notImm = getSlowCase(iter);
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitFastArithIntToImmNoCheck(X86::edx);
-            __ link(notImm, __ label());
+            notImm.link(this);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
             emitCTICall(i, Interpreter::cti_op_get_by_val);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
-            __ link(__ jmp(), m_labels[i + 4]);
+            __ link(jump(), m_labels[i + 4]);
 
             // This is slow case that handles accesses to arrays above the fast cut-off.
             // First, check if this is an access to the vector
-            __ link((++iter)->from, __ label());
-            __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
-            __ link(__ jbe(), beginGetByValSlow);
+            linkSlowCase(iter);
+            jae32(X86::edx, Address(X86::ecx, FIELD_OFFSET(ArrayStorage, m_vectorLength)), beginGetByValSlow);
 
             // okay, missed the fast region, but it is still in the vector.  Get the value.
-            __ movl_mr(FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::ecx);
+            loadPtr(BaseIndex(X86::ecx, X86::edx, ScalePtr, FIELD_OFFSET(ArrayStorage, m_vector[0])), X86::ecx);
             // Check whether the value loaded is zero; if so we need to return undefined.
-            __ testl_rr(X86::ecx, X86::ecx);
-            __ link(__ je(), beginGetByValSlow);
-            __ movl_rr(X86::ecx, X86::eax);
+            jzPtr(X86::ecx, beginGetByValSlow);
+            move(X86::ecx, X86::eax);
             emitPutVirtualRegister(instruction[i + 1].u.operand, X86::eax);
 
@@ -1484 +1469 @@
         case op_rshift: {
             unsigned src2 = instruction[i + 3].u.operand;
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             if (getConstantImmediateNumericArg(src2))
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
             else {
-                __ link((++iter)->from, __ label());
+                linkSlowCase(iter);
                 emitPutCTIArg(X86::ecx, 4);
             }
@@ -1499 +1484 @@
         }
         case op_lshift: {
-            JmpSrc notImm1 = iter->from;
-            JmpSrc notImm2 = (++iter)->from;
-            __ link((++iter)->from, __ label());
+            Jump notImm1 = getSlowCase(iter);
+            Jump notImm2 = getSlowCase(iter);
+            linkSlowCase(iter);
             emitGetVirtualRegisters(instruction[i + 2].u.operand, X86::eax, instruction[i + 3].u.operand, X86::ecx, i);
-            __ link(notImm1, __ label());
-            __ link(notImm2, __ label());
+            notImm1.link(this);
+            notImm2.link(this);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
@@ -1516 +1501 @@
             JSValue* src2imm = getConstantImmediateNumericArg(instruction[i + 2].u.operand);
             if (src2imm) {
-                __ link(iter->from, __ label());
+                linkSlowCase(iter);
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
                 emitCTICall(i, Interpreter::cti_op_loop_if_less);
-                __ testl_rr(X86::eax, X86::eax);
-                __ link(__ jne(), m_labels[i + 3 + target]);
+                __ link(jnz32(X86::eax), m_labels[i + 3 + target]);
             } else {
-                __ link(iter->from, __ label());
-                __ link((++iter)->from, __ label());
+                linkSlowCase(iter);
+                linkSlowCase(iter);
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
                 emitCTICall(i, Interpreter::cti_op_loop_if_less);
-                __ testl_rr(X86::eax, X86::eax);
-                __ link(__ jne(), m_labels[i + 3 + target]);
+                __ link(jnz32(X86::eax), m_labels[i + 3 + target]);
             }
             i += OPCODE_LENGTH(op_loop_if_less);
@@ -1548 +1531 @@
             JSValue* src2imm = getConstantImmediateNumericArg(instruction[i + 2].u.operand);
             if (src2imm) {
-                __ link(iter->from, __ label());
+                linkSlowCase(iter);
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
                 emitCTICall(i, Interpreter::cti_op_loop_if_lesseq);
-                __ testl_rr(X86::eax, X86::eax);
-                __ link(__ jne(), m_labels[i + 3 + target]);
+                __ link(jnz32(X86::eax), m_labels[i + 3 + target]);
             } else {
-                __ link(iter->from, __ label());
-                __ link((++iter)->from, __ label());
+                linkSlowCase(iter);
+                linkSlowCase(iter);
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
                 emitCTICall(i, Interpreter::cti_op_loop_if_lesseq);
-                __ testl_rr(X86::eax, X86::eax);
-                __ link(__ jne(), m_labels[i + 3 + target]);
+                __ link(jnz32(X86::eax), m_labels[i + 3 + target]);
             }
             i += OPCODE_LENGTH(op_loop_if_lesseq);
@@ -1568 +1549 @@
         case op_pre_inc: {
             unsigned srcDst = instruction[i + 1].u.operand;
-            JmpSrc notImm = iter->from;
-            __ link((++iter)->from, __ label());
-            __ subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
-            __ link(notImm, __ label());
+            Jump notImm = getSlowCase(iter);
+            linkSlowCase(iter);
+            sub32(Imm32(getDeTaggedConstantImmediate(JSImmediate::oneImmediate())), X86::eax);
+            notImm.link(this);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_pre_inc);
@@ -1580 +1561 @@
         case op_put_by_val: {
             // Normal slow cases - either is not an immediate imm, or is an array.
-            JmpSrc notImm = iter->from;
-            __ link((++iter)->from, __ label());
-            __ link((++iter)->from, __ label());
+            Jump notImm = getSlowCase(iter);
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitFastArithIntToImmNoCheck(X86::edx);
-            __ link(notImm, __ label());
+            notImm.link(this);
             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::ecx, i);
             emitPutCTIArg(X86::eax, 0);
@@ -1590 +1571 @@
             emitPutCTIArg(X86::ecx, 8);
             emitCTICall(i, Interpreter::cti_op_put_by_val);
-            __ link(__ jmp(), m_labels[i + 4]);
+            __ link(jump(), m_labels[i + 4]);
 
             // slow cases for immediate int accesses to arrays
-            __ link((++iter)->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::ecx, i);
             emitPutCTIArg(X86::eax, 0);
@@ -1605 +1586 @@
         }
         case op_loop_if_true: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_jtrue);
-            __ testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
-            __ link(__ jne(), m_labels[i + 2 + target]);
+            __ link(jnz32(X86::eax), m_labels[i + 2 + target]);
             i += OPCODE_LENGTH(op_loop_if_true);
             break;
@@ -1616 +1596 @@
         case op_pre_dec: {
             unsigned srcDst = instruction[i + 1].u.operand;
-            JmpSrc notImm = iter->from;
-            __ link((++iter)->from, __ label());
-            __ addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
-            __ link(notImm, __ label());
+            Jump notImm = getSlowCase(iter);
+            linkSlowCase(iter);
+            add32(Imm32(getDeTaggedConstantImmediate(JSImmediate::oneImmediate())), X86::eax);
+            notImm.link(this);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_pre_dec);
@@ -1630 +1610 @@
             JSValue* src2imm = getConstantImmediateNumericArg(instruction[i + 2].u.operand);
             if (src2imm) {
-                __ link(iter->from, __ label());
+                linkSlowCase(iter);
                 emitPutCTIArg(X86::edx, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
                 emitCTICall(i, Interpreter::cti_op_jless);
-                __ testl_rr(X86::eax, X86::eax);
-                __ link(__ je(), m_labels[i + 3 + target]);
+                __ link(jz32(X86::eax), m_labels[i + 3 + target]);
             } else {
-                __ link(iter->from, __ label());
-                __ link((++iter)->from, __ label());
+                linkSlowCase(iter);
+                linkSlowCase(iter);
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
                 emitCTICall(i, Interpreter::cti_op_jless);
-                __ testl_rr(X86::eax, X86::eax);
-                __ link(__ je(), m_labels[i + 3 + target]);
+                __ link(jz32(X86::eax), m_labels[i + 3 + target]);
             }
             i += OPCODE_LENGTH(op_jnless);
@@ -1649 +1627 @@
         }
         case op_not: {
-            __ link(iter->from, __ label());
-            __ xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
+            linkSlowCase(iter);
+            xor32(Imm32(JSImmediate::FullTagTypeBool), X86::eax);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_not);
@@ -1658 +1636 @@
         }
         case op_jfalse: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_jtrue);
-            __ testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
-            __ link(__ je(), m_labels[i + 2 + target]); // inverted!
+            __ link(jz32(X86::eax), m_labels[i + 2 + target]); // inverted!
             i += OPCODE_LENGTH(op_jfalse);
             break;
@@ -1669 +1646 @@
         case op_post_inc: {
             unsigned srcDst = instruction[i + 2].u.operand;
-            __ link(iter->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_post_inc);
@@ -1679 +1656 @@
         }
         case op_bitnot: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_bitnot);
@@ -1687 +1664 @@
         }
         case op_bitand: {
+            linkSlowCase(iter);
             unsigned src1 = instruction[i + 2].u.operand;
             unsigned src2 = instruction[i + 3].u.operand;
             unsigned dst = instruction[i + 1].u.operand;
             if (getConstantImmediateNumericArg(src1)) {
-                __ link(iter->from, __ label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::eax, 4);
@@ -1697 +1674 @@
                 emitPutVirtualRegister(dst);
             } else if (getConstantImmediateNumericArg(src2)) {
-                __ link(iter->from, __ label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
@@ -1703 +1679 @@
                 emitPutVirtualRegister(dst);
             } else {
-                __ link(iter->from, __ label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::edx, 4);
@@ -1713 +1688 @@
         }
         case op_jtrue: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_jtrue);
-            __ testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
-            __ link(__ jne(), m_labels[i + 2 + target]);
+            __ link(jnz32(X86::eax), m_labels[i + 2 + target]);
             i += OPCODE_LENGTH(op_jtrue);
             break;
@@ -1724 +1698 @@
         case op_post_dec: {
             unsigned srcDst = instruction[i + 2].u.operand;
-            __ link(iter->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitCTICall(i, Interpreter::cti_op_post_dec);
@@ -1734 +1708 @@
         }
         case op_bitxor: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
@@ -1743 +1717 @@
         }
         case op_bitor: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
@@ -1752 +1726 @@
         }
         case op_eq: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
@@ -1761 +1735 @@
         }
         case op_neq: {
-            __ link(iter->from, __ label());
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
@@ -1770 +1744 @@
         }
         case op_stricteq: {
-            __ link(iter->from, __ label());
-            __ link((++iter)->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
@@ -1781 +1755 @@
         }
         case op_nstricteq: {
-            __ link(iter->from, __ label());
-            __ link((++iter)->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
@@ -1792 +1766 @@
         }
         case op_instanceof: {
-            __ link(iter->from, __ label());
-            __ link((++iter)->from, __ label());
-            __ link((++iter)->from, __ label());
+            linkSlowCase(iter);
+            linkSlowCase(iter);
+            linkSlowCase(iter);
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
@@ -1804 +1778 @@
         }
         case op_mod: {
-            JmpSrc notImm1 = iter->from;
-            JmpSrc notImm2 = (++iter)->from;
-            __ link((++iter)->from, __ label());
+            Jump notImm1 = getSlowCase(iter);
+            Jump notImm2 = getSlowCase(iter);
+            linkSlowCase(iter);
             emitFastArithReTagImmediate(X86::eax);
             emitFastArithReTagImmediate(X86::ecx);
-            __ link(notImm1, __ label());
-            __ link(notImm2, __ label());
+            notImm1.link(this);
+            notImm2.link(this);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
@@ -1826 +1800 @@
             int32_t value;
             if (src1Value && ((value = JSImmediate::intValue(src1Value)) > 0)) {
-                __ link(iter->from, __ label());
-                __ link((++iter)->from, __ label());
+                linkSlowCase(iter);
+                linkSlowCase(iter);
                 // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
@@ -1834 +1808 @@
                 emitPutVirtualRegister(dst);
             } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) {
-                __ link(iter->from, __ label());
-                __ link((++iter)->from, __ label());
+                linkSlowCase(iter);
+                linkSlowCase(iter);
                 // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
@@ -1855 +1829 @@
         }
         case op_to_jsnumber: {
-            if (linkSlowCaseIfNotJSCell(iter, instruction[i + 2].u.operand))
-                ++iter;
-            __ link(iter->from, __ label());
+            linkSlowCaseIfNotJSCell(iter, instruction[i + 2].u.operand);
+            linkSlowCase(iter);
 
             emitPutCTIArg(X86::eax, 0);
@@ -1872 +1845 @@
         }
 
-        ASSERT_WITH_MESSAGE((iter + 1) == m_slowCases.end() || firstTo != (iter + 1)->to,"Not enough jumps linked in slow case codegen.");
-        ASSERT_WITH_MESSAGE(firstTo == iter->to, "Too many jumps linked in slow case codegen.");
-
-        __ link(__ jmp(), m_labels[i]);
+        ASSERT_WITH_MESSAGE(iter == m_slowCases.end() || firstTo != iter->to,"Not enough jumps linked in slow case codegen.");
+        ASSERT_WITH_MESSAGE(firstTo == (iter - 1)->to, "Too many jumps linked in slow case codegen.");
+
+        __ link(jump(), m_labels[i]);
     }
 
@@ -1885 +1858 @@
 {
 #if ENABLE(CODEBLOCK_SAMPLING)
-        __ movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
+        storePtr(ImmPtr(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
 #endif
 #if ENABLE(OPCODE_SAMPLING)
-        __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions().begin()), m_interpreter->sampler()->sampleSlot());
+        store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions().begin())), m_interpreter->sampler()->sampleSlot());
 #endif
 
@@ -1895 +1868 @@
     emitPutToCallFrameHeader(X86::ecx, RegisterFile::ReturnPC);
 
-    JmpSrc slowRegisterFileCheck;
-    JmpDst afterRegisterFileCheck;
+    Jump slowRegisterFileCheck;
+    Label afterRegisterFileCheck;
     if (m_codeBlock->codeType() == FunctionCode) {
         // In the case of a fast linked call, we do not set this up in the caller.
@@ -1903 +1876 @@
         emitGetCTIParam(CTI_ARGS_registerFile, X86::eax);
         __ leal_mr(m_codeBlock->m_numCalleeRegisters * sizeof(Register), X86::edi, X86::edx);
-        __ cmpl_mr(FIELD_OFFSET(RegisterFile, m_end), X86::eax, X86::edx);
-        slowRegisterFileCheck = __ jg();
-        afterRegisterFileCheck = __ label();
+        slowRegisterFileCheck = jg32(X86::edx, Address(X86::eax, FIELD_OFFSET(RegisterFile, m_end)));
+        afterRegisterFileCheck = Label(this);
     }
 
@@ -1913 +1885 @@
 
     if (m_codeBlock->codeType() == FunctionCode) {
-        __ link(slowRegisterFileCheck, __ label());
+        slowRegisterFileCheck.link(this);
         emitCTICall(0, Interpreter::cti_register_file_check);
-        JmpSrc backToBody = __ jmp();
-        __ link(backToBody, afterRegisterFileCheck);
+        jump(afterRegisterFileCheck);
     }
 
@@ -2171 +2142 @@
 void JIT::emitGetVariableObjectRegister(RegisterID variableObject, int index, RegisterID dst)
 {
-    __ movl_mr(FIELD_OFFSET(JSVariableObject, d), variableObject, dst);
-    __ movl_mr(FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers), dst, dst);
-    __ movl_mr(index * sizeof(Register), dst, dst);
+    loadPtr(Address(variableObject, FIELD_OFFSET(JSVariableObject, d)), dst);
+    loadPtr(Address(dst, FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers)), dst);
+    loadPtr(Address(dst, index * sizeof(Register)), dst);
 }
 
 void JIT::emitPutVariableObjectRegister(RegisterID src, RegisterID variableObject, int index)
 {
-    __ movl_mr(FIELD_OFFSET(JSVariableObject, d), variableObject, variableObject);
-    __ movl_mr(FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers), variableObject, variableObject);
-    __ movl_rm(src, index * sizeof(Register), variableObject);
+    loadPtr(Address(variableObject, FIELD_OFFSET(JSVariableObject, d)), variableObject);
+    loadPtr(Address(variableObject, FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers)), variableObject);
+    storePtr(src, Address(variableObject, index * sizeof(Register)));
 }
 

trunk/JavaScriptCore/jit/JIT.h

@@ -194 +194 @@
 
     struct SlowCaseEntry {
-        typedef X86Assembler::JmpSrc JmpSrc;
-
-        JmpSrc from;
+        MacroAssembler::Jump from;
         unsigned to;
         unsigned hint;
         
-        SlowCaseEntry(JmpSrc f, unsigned t, unsigned h = 0)
+        SlowCaseEntry(MacroAssembler::Jump f, unsigned t, unsigned h = 0)
             : from(f)
             , to(t)
@@ -434 +432 @@
         void emitJumpSlowCaseIfNotJSCell(RegisterID, unsigned bytecodeIndex);
         void emitJumpSlowCaseIfNotJSCell(RegisterID, unsigned bytecodeIndex, int VReg);
-        bool linkSlowCaseIfNotJSCell(const Vector<SlowCaseEntry>::iterator&, int vReg);
+
+        Jump getSlowCase(Vector<SlowCaseEntry>::iterator& iter)
+        {
+            return iter++->from;
+        }
+        void linkSlowCase(Vector<SlowCaseEntry>::iterator& iter)
+        {
+            iter->from.link(this);
+            ++iter;
+        }
+        void linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator&, int vReg);
 
         void emitJumpSlowCaseIfNotImmNum(RegisterID, unsigned bytecodeIndex);

trunk/JavaScriptCore/jit/JITArithmetic.cpp

@@ -298 +298 @@
 void JIT::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
 {
-    JmpDst here = __ label();
-    __ link(iter->from, here);
+    linkSlowCase(iter);
     if (types.second().isReusable() && isSSE2Present()) {
         if (!types.first().definitelyIsNumber()) {
-            if (linkSlowCaseIfNotJSCell(++iter, src1))
-                ++iter;
-            __ link(iter->from, here);
+            linkSlowCaseIfNotJSCell(iter, src1);
+            linkSlowCase(iter);
         }
         if (!types.second().definitelyIsNumber()) {
-            if (linkSlowCaseIfNotJSCell(++iter, src2))
-                ++iter;
-            __ link(iter->from, here);
-        }
-        __ link((++iter)->from, here);
+            linkSlowCaseIfNotJSCell(iter, src2);
+            linkSlowCase(iter);
+        }
     } else if (types.first().isReusable() && isSSE2Present()) {
         if (!types.first().definitelyIsNumber()) {
-            if (linkSlowCaseIfNotJSCell(++iter, src1))
-                ++iter;
-            __ link(iter->from, here);
+            linkSlowCaseIfNotJSCell(iter, src1);
+            linkSlowCase(iter);
         }
         if (!types.second().definitelyIsNumber()) {
-            if (linkSlowCaseIfNotJSCell(++iter, src2))
-                ++iter;
-            __ link(iter->from, here);
-        }
-        __ link((++iter)->from, here);
-    } else
-        __ link((++iter)->from, here);
+            linkSlowCaseIfNotJSCell(iter, src2);
+            linkSlowCase(iter);
+        }
+    }
+    linkSlowCase(iter);
 
     // additional entry point to handle -0 cases.
     if (opcodeID == op_mul)
-        __ link((++iter)->from, here);
+        linkSlowCase(iter);
 
     emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);

trunk/JavaScriptCore/jit/JITCall.cpp

@@ -72 +72 @@
 void JIT::compileOpCallInitializeCallFrame()
 {
-    __ movl_rm(X86::edx, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register)), X86::edi);
-
-    __ movl_mr(FIELD_OFFSET(JSFunction, m_scopeChain) + FIELD_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
-
-    __ movl_i32m(asInteger(noValue()), RegisterFile::OptionalCalleeArguments * static_cast<int>(sizeof(Register)), X86::edi);
-    __ movl_rm(X86::ecx, RegisterFile::Callee * static_cast<int>(sizeof(Register)), X86::edi);
-    __ movl_rm(X86::edx, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register)), X86::edi);
+    store32(X86::edx, Address(X86::edi, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register))));
+
+    loadPtr(Address(X86::ecx, FIELD_OFFSET(JSFunction, m_scopeChain) + FIELD_OFFSET(ScopeChain, m_node)), X86::edx); // newScopeChain
+
+    storePtr(ImmPtr(noValue()), Address(X86::edi, RegisterFile::OptionalCalleeArguments * static_cast<int>(sizeof(Register))));
+    storePtr(X86::ecx, Address(X86::edi, RegisterFile::Callee * static_cast<int>(sizeof(Register))));
+    storePtr(X86::edx, Address(X86::edi, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register))));
 }
 
@@ -131 +131 @@
 
     // Handle eval
-    JmpSrc wasEval;
+    Jump wasEval;
     if (opcodeID == op_call_eval) {
         emitGetVirtualRegister(callee, X86::ecx, i);
@@ -137 +137 @@
 
         emitCTICall(i, Interpreter::cti_op_call_eval);
-        __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
-        wasEval = __ jne();
+        wasEval = jnePtr(ImmPtr(JSImmediate::impossibleValue()), X86::eax);
     }
 
@@ -150 +149 @@
     // Check for JSFunctions.
     emitJumpSlowCaseIfNotJSCell(X86::ecx, i);
-    __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsFunctionVptr), X86::ecx);
-    m_slowCases.append(SlowCaseEntry(__ jne(), i));
+    m_slowCases.append(SlowCaseEntry(jnePtr(X86::ecx, ImmPtr(m_interpreter->m_jsFunctionVptr)), i));
 
     // First, in the case of a construct, allocate the new object.
@@ -161 +159 @@
 
     // Speculatively roll the callframe, assuming argCount will match the arity.
-    __ movl_rm(X86::edi, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register)), X86::edi);
-    __ addl_i32r(registerOffset * static_cast<int>(sizeof(Register)), X86::edi);
-    __ movl_i32r(argCount, X86::edx);
+    storePtr(X86::edi, Address(X86::edi, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
+    addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), X86::edi);
+    move(Imm32(argCount), X86::edx);
 
     emitNakedCall(i, m_interpreter->m_ctiVirtualCall);
 
     if (opcodeID == op_call_eval)
-        __ link(wasEval, __ label());
+        wasEval.link(this);
 
     // Put the return value in dst. In the interpreter, op_ret does this.
@@ -174 +172 @@
 
 #if ENABLE(CODEBLOCK_SAMPLING)
-    __ movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
+    storePtr(ImmPtr(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
 #endif
 }
@@ -182 +180 @@
     int dst = instruction[1].u.operand;
 
-    __ link(iter->from, __ label());
-    __ link((++iter)->from, __ label());
+    linkSlowCase(iter);
+    linkSlowCase(iter);
 
     // This handles host functions
@@ -191 +189 @@
 
 #if ENABLE(CODEBLOCK_SAMPLING)
-    __ movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
+    storePtr(ImmPtr(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
 #endif
 }
@@ -275 +273 @@
     int registerOffset = instruction[4].u.operand;
 
-    __ link(iter->from, __ label());
+    linkSlowCase(iter);
 
     // The arguments have been set up on the hot path for op_call_eval

trunk/JavaScriptCore/jit/JITInlineMethods.h

@@ -341 +341 @@
 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg, unsigned bytecodeIndex, int vReg)
 {
-    if (m_codeBlock->isKnownNotImmediate(vReg))
-        return;
-
-    emitJumpSlowCaseIfNotJSCell(reg, bytecodeIndex);
-}
-
-ALWAYS_INLINE bool JIT::linkSlowCaseIfNotJSCell(const Vector<SlowCaseEntry>::iterator& iter, int vReg)
-{
-    if (m_codeBlock->isKnownNotImmediate(vReg))
-        return false;
-    
-    __ link(iter->from, __ label());
-    return true;
+    if (!m_codeBlock->isKnownNotImmediate(vReg))
+        emitJumpSlowCaseIfNotJSCell(reg, bytecodeIndex);
+}
+
+ALWAYS_INLINE void JIT::linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator& iter, int vReg)
+{
+    if (!m_codeBlock->isKnownNotImmediate(vReg))
+        linkSlowCase(iter);
 }
 

trunk/JavaScriptCore/jit/JITPropertyAccess.cpp

@@ -47 +47 @@
 #if !ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
 
-void JIT::compileGetByIdHotPath(int resultVReg, int baseVReg, Identifier* ident, unsigned i, unsigned propertyAccessInstructionIndex)
+void JIT::compileGetByIdHotPath(int resultVReg, int baseVReg, Identifier* ident, unsigned i, unsigned)
 {
     // As for put_by_id, get_by_id requires the offset of the Structure and the offset of the access to be repatched.
@@ -56 +56 @@
     emitGetVirtualRegister(baseVReg, X86::eax, i);
 
-#ifdef NDEBUG
-    UNUSED_PARAM(propertyAccessInstructionIndex);
-#endif
-
-#ifndef NDEBUG
-    JmpDst coldPathBegin = __ label();
-#endif        
     emitPutCTIArg(X86::eax, 0);
     emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
-    JmpSrc call = emitCTICall(i, Interpreter::cti_op_get_by_id_generic);
-    ASSERT(X86Assembler::getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
+    emitCTICall(i, Interpreter::cti_op_get_by_id_generic);
     emitPutVirtualRegister(resultVReg);
-
-    // Track the location of the call; this will be used to recover repatch information.
-    m_propertyAccessCompilationInfo[propertyAccessInstructionIndex].callReturnLocation = call;
 }
 
@@ -79 +68 @@
 }
 
-void JIT::compilePutByIdHotPath(int baseVReg, Identifier* ident, int valueVReg, unsigned i, unsigned propertyAccessInstructionIndex)
+void JIT::compilePutByIdHotPath(int baseVReg, Identifier* ident, int valueVReg, unsigned i, unsigned)
 {
     // In order to be able to repatch both the Structure, and the object offset, we store one pointer,
@@ -90 +79 @@
     emitPutCTIArg(X86::eax, 0);
     emitPutCTIArg(X86::edx, 8);
-    JmpSrc call = emitCTICall(i, Interpreter::cti_op_put_by_id_generic);
-
-    // Track the location of the call; this will be used to recover repatch information.
-    m_propertyAccessCompilationInfo[propertyAccessInstructionIndex].callReturnLocation = call;
+    emitCTICall(i, Interpreter::cti_op_put_by_id_generic);
 }
 
@@ -137 +123 @@
     // the distance from the call to the head of the slow case.
 
-    if (linkSlowCaseIfNotJSCell(iter, baseVReg))
-        ++iter;
-    __ link(iter->from, __ label());
+    linkSlowCaseIfNotJSCell(iter, baseVReg);
+    linkSlowCase(iter);
 
 #ifndef NDEBUG
@@ -181 +166 @@
 void JIT::compilePutByIdSlowCase(int baseVReg, Identifier* ident, int, unsigned i, Vector<SlowCaseEntry>::iterator& iter, unsigned propertyAccessInstructionIndex)
 {
-    if (linkSlowCaseIfNotJSCell(iter, baseVReg))
-        ++iter;
-    __ link(iter->from, __ label());
+    linkSlowCaseIfNotJSCell(iter, baseVReg);
+    linkSlowCase(iter);
 
     emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);