Changeset 36324 in webkit for trunk/JavaScriptCore

Timestamp:

Sep 10, 2008, 7:10:47 PM (17 years ago)

Author:

[email protected]

Message:

Inline immediate number version of op_mul.

Reviewed by Geoff Garen

Renamed mull_rr to imull_rr as that's what it's
actually doing, and added imull_i32r for the constant
case immediate multiply.

1.1% improvement to SunSpider.

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• VM/CTI.cpp (modified) (4 diffs)
• masm/X86Assembler.h (modified) (3 diffs)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-09-10  Oliver Hunt  <[email protected]>
+
+        Reviewed by Geoff Garen.
+
+        Inline immediate number version of op_mul.
+
+        Renamed mull_rr to imull_rr as that's what it's 
+        actually doing, and added imull_i32r for the constant
+        case immediate multiply.
+
+        1.1% improvement to SunSpider.
+
+        * VM/CTI.cpp:
+        (JSC::CTI::privateCompileMainPass):
+        (JSC::CTI::privateCompileSlowCases):
+        * masm/X86Assembler.h:
+        (JSC::X86Assembler::):
+        (JSC::X86Assembler::imull_rr):
+        (JSC::X86Assembler::imull_i32r):
+
 2008-09-10  Cameron Zwarich  <[email protected]>
 

trunk/JavaScriptCore/VM/CTI.cpp

@@ -615 +615 @@
             break;
         }
-        CTI_COMPILE_BINARY_OP(op_mul);
+        case op_mul: {
+            unsigned dst = instruction[i + 1].u.operand;
+            unsigned src1 = instruction[i + 2].u.operand;
+            unsigned src2 = instruction[i + 3].u.operand;
+            if (src1 < m_codeBlock->constantRegisters.size() || src2 < m_codeBlock->constantRegisters.size()) {
+                unsigned constant = src1;
+                unsigned nonconstant = src2;
+                if (!(src1 < m_codeBlock->constantRegisters.size())) {
+                    constant = src2;
+                    nonconstant = src1;
+                }
+                JSValue* value = m_codeBlock->constantRegisters[constant].jsValue(m_exec);
+                if (JSImmediate::isNumber(value)) {
+                    emitGetArg(nonconstant, X86::eax);
+                    emitJumpSlowCaseIfNotImm(X86::eax, i);
+                    emitFastArithImmToInt(X86::eax);
+                    m_jit.imull_i32r( X86::eax, getDeTaggedConstantImmediate(value), X86::eax);
+                    m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
+                    emitFastArithPotentiallyReTagImmediate(X86::eax);
+                    emitPutResult(dst);
+                    i += 4;
+                    break;
+                }
+            }
+
+            emitGetArg(src1, X86::eax);
+            emitGetArg(src2, X86::edx);
+            emitJumpSlowCaseIfNotImms(X86::eax, X86::edx, i);
+            emitFastArithDeTagImmediate(X86::eax);
+            emitFastArithImmToInt(X86::edx);
+            m_jit.imull_rr(X86::edx, X86::eax);
+            m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
+            emitFastArithPotentiallyReTagImmediate(X86::eax);
+            emitPutResult(dst);
+            i += 4;
+            break;
+        }
         case op_new_func: {
             FuncDeclNode* func = (m_codeBlock->functions[instruction[i + 2].u.operand]).get();
@@ -1283 +1319 @@
 }
 
+#define CTI_COMPILE_BINARY_OP_SLOW_CASE(name) \
+    case name: { \
+        m_jit.link(iter->from, m_jit.label()); \
+        emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
+        emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx); \
+        emitCall(i, Machine::cti_##name); \
+        emitPutResult(instruction[i + 1].u.operand); \
+        i += 4; \
+        break; \
+    }
+    
 void CTI::privateCompileSlowCases()
 {
@@ -1288 +1335 @@
     for (Vector<SlowCaseEntry>::iterator iter = m_slowCases.begin(); iter != m_slowCases.end(); ++iter) {
         int i = iter->to;
-       m_jit.emitRestoreArgumentReference();
+        m_jit.emitRestoreArgumentReference();
         switch (m_machine->getOpcodeID(instruction[i].u.opcode)) {
         case op_add: {
@@ -1590 +1637 @@
             break;
         }
+        CTI_COMPILE_BINARY_OP_SLOW_CASE(op_mul);
         default:
             ASSERT_NOT_REACHED();

trunk/JavaScriptCore/masm/X86Assembler.h

@@ -183 +183 @@
         OP_POP_EAX                      = 0x58,
         PRE_OPERAND_SIZE                = 0x66,
+        OP_IMUL_GvEvIz                  = 0x69,
         OP_GROUP1_EvIz                  = 0x81,
         OP_GROUP1_EvIb                  = 0x83,
@@ -212 +213 @@
         OP2_JGE_rel32   = 0x8D,
         OP2_JLE_rel32   = 0x8E,
-        OP2_MUL_GvEv    = 0xAF,
+        OP2_IMUL_GvEv   = 0xAF,
         OP2_MOVZX_GvEw  = 0xB7,
 
@@ -473 +474 @@
     }
 
-    void mull_rr(RegisterID src, RegisterID dst)
-    {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MUL_GvEv);
+    void imull_rr(RegisterID src, RegisterID dst)
+    {
+        m_buffer->putByte(OP_2BYTE_ESCAPE);
+        m_buffer->putByte(OP2_IMUL_GvEv);
         emitModRm_rr(dst, src);
+    }
+    
+    void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
+    {
+        m_buffer->putByte(OP_IMUL_GvEvIz);
+        emitModRm_rr(dst, src);
+        m_buffer->putInt(value);
     }