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

Timestamp:

Dec 5, 2008, 3:57:43 PM (16 years ago)

Author:

[email protected]

Message:

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

Reviewed by Geoff Garen.

Move JIT::compileOpStrictEq to MacroAssembler interface.

The rewrite also looks like a small (<1%) performance progression.

​https://bugs.webkit.org/show_bug.cgi?id=22697

• jit/JIT.cpp: (JSC::JIT::compileOpStrictEq): (JSC::JIT::privateCompileSlowCases):
• jit/JIT.h:
• jit/JITInlineMethods.h: (JSC::JIT::emitJumpIfJSCell): (JSC::JIT::emitJumpSlowCaseIfJSCell):

File:

• trunk/JavaScriptCore/jit/JIT.cpp (modified) (3 diffs)

trunk/JavaScriptCore/jit/JIT.cpp

@@ -222 +222 @@
     emitGetVirtualRegisters(src1, X86::eax, src2, X86::edx, i);
 
-    __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    JmpSrc firstNotImmediate = __ je();
-    __ testl_i32r(JSImmediate::TagMask, X86::edx);
-    JmpSrc secondNotImmediate = __ je();
-
-    __ cmpl_rr(X86::edx, X86::eax);
-    if (negated)
-        __ setne_r(X86::eax);
-    else
-        __ sete_r(X86::eax);
-    __ movzbl_rr(X86::eax, X86::eax);
-    emitTagAsBoolImmediate(X86::eax);
-            
-    JmpSrc bothWereImmediates = __ jmp();
-
-    __ link(firstNotImmediate, __ label());
-
-    // check that edx is immediate but not the zero immediate
-    __ testl_i32r(JSImmediate::TagMask, X86::edx);
-    __ setz_r(X86::ecx);
-    __ movzbl_rr(X86::ecx, X86::ecx); // ecx is now 1 if edx was nonimmediate
-    __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::edx);
-    __ sete_r(X86::edx);
-    __ movzbl_rr(X86::edx, X86::edx); // edx is now 1 if edx was the 0 immediate
-    __ orl_rr(X86::ecx, X86::edx);
-
-    m_slowCases.append(SlowCaseEntry(__ jnz(), i));
-
-    __ movl_i32r(asInteger(jsBoolean(negated)), X86::eax);
-
-    JmpSrc firstWasNotImmediate = __ jmp();
-
-    __ link(secondNotImmediate, __ label());
-    // check that eax is not the zero immediate (we know it must be immediate)
-    __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
-    m_slowCases.append(SlowCaseEntry(__ je(), i));
-
-    __ movl_i32r(asInteger(jsBoolean(negated)), X86::eax);
-
-    __ link(bothWereImmediates, __ label());
-    __ link(firstWasNotImmediate, __ label());
-
+    // Check that bot are immediates, if so check if they're equal
+    Jump firstNotImmediate = emitJumpIfJSCell(X86::eax);
+    Jump secondNotImmediate = emitJumpIfJSCell(X86::edx);
+    Jump bothWereImmediatesButNotEqual = jne32(X86::edx, X86::eax);
+
+    // They are equal - set the result to true. (Or false, if negated).
+    move(Imm32(asInteger(jsBoolean(!negated))), X86::eax);
+    Jump bothWereImmediatesAndEqual = jump();
+
+    // eax was not an immediate, we haven't yet checked edx.
+    // If edx is also a JSCell, or is 0, then jump to a slow case,
+    // otherwise these values are not equal.
+    firstNotImmediate.link(this);
+    emitJumpSlowCaseIfJSCell(X86::edx, i);
+    m_slowCases.append(SlowCaseEntry(je32(Imm32(asInteger(JSImmediate::zeroImmediate())), X86::edx), i));
+    Jump firstWasNotImmediate = jump();
+
+    // eax was an immediate, but edx wasn't.
+    // If eax is 0 jump to a slow case, otherwise these values are not equal.
+    secondNotImmediate.link(this);
+    m_slowCases.append(SlowCaseEntry(je32(Imm32(asInteger(JSImmediate::zeroImmediate())), X86::eax), i));
+
+    // We get here if the two values are different immediates, or one is 0 and the other is a JSCell.
+    // Vaelues are not equal, set the result to false.
+    bothWereImmediatesButNotEqual.link(this);
+    firstWasNotImmediate.link(this);
+    move(Imm32(asInteger(jsBoolean(negated))), X86::eax);
+    
+    bothWereImmediatesAndEqual.link(this);
     emitPutVirtualRegister(dst);
 }
@@ -1485 +1472 @@
     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; \
-    }
-
-#define CTI_COMPILE_BINARY_OP_SLOW_CASE_DOUBLE_ENTRY(name) \
-    case name: { \
-        __ link(iter->from, __ label()); \
-        __ link((++iter)->from, __ label());                \
         emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
@@ -1893 +1868 @@
             break;
         }
-        CTI_COMPILE_BINARY_OP_SLOW_CASE_DOUBLE_ENTRY(op_stricteq);
-        CTI_COMPILE_BINARY_OP_SLOW_CASE_DOUBLE_ENTRY(op_nstricteq);
+        case op_stricteq: {
+            __ link(iter->from, __ label());
+            __ link((++iter)->from, __ label());
+            __ link((++iter)->from, __ label());
+            emitPutCTIArg(X86::eax, 0);
+            emitPutCTIArg(X86::edx, 4);
+            emitCTICall(i, Interpreter::cti_op_stricteq);
+            emitPutVirtualRegister(instruction[i + 1].u.operand);
+            i += 4;
+            break;
+        }
+        case op_nstricteq: {
+            __ link(iter->from, __ label());
+            __ link((++iter)->from, __ label());
+            __ link((++iter)->from, __ label());
+            emitPutCTIArg(X86::eax, 0);
+            emitPutCTIArg(X86::edx, 4);
+            emitCTICall(i, Interpreter::cti_op_nstricteq);
+            emitPutVirtualRegister(instruction[i + 1].u.operand);
+            i += 4;
+            break;
+        }
         case op_instanceof: {
             __ link(iter->from, __ label());