Changeset 36738 in webkit for trunk/JavaScriptCore/VM

Timestamp:

Sep 21, 2008, 3:39:29 AM (17 years ago)

Author:

[email protected]

Message:

2008-09-21 Maciej Stachowiak <​[email protected]>

Reviewed by Oliver.

• speed up === operator by generating inline machine code for the fast paths ​https://bugs.webkit.org/show_bug.cgi?id=20820

• VM/CTI.cpp: (JSC::CTI::emitJumpSlowCaseIfNotImmediateNumber): (JSC::CTI::emitJumpSlowCaseIfNotImmediateNumbers): (JSC::CTI::emitJumpSlowCaseIfNotImmediates): (JSC::CTI::emitTagAsBoolImmediate): (JSC::CTI::privateCompileMainPass): (JSC::CTI::privateCompileSlowCases):
• VM/CTI.h:
• VM/Machine.cpp: (JSC::Machine::cti_op_stricteq):
• masm/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::sete_r): (JSC::X86Assembler::setz_r): (JSC::X86Assembler::movzbl_rr): (JSC::X86Assembler::emitUnlinkedJnz):

Location:

trunk/JavaScriptCore/VM

Files:

• CTI.cpp (modified) (3 diffs)
• CTI.h (modified) (1 diff)
• Machine.cpp (modified) (1 diff)

trunk/JavaScriptCore/VM/CTI.cpp

@@ -388 +388 @@
 }
 
+ALWAYS_INLINE void CTI::emitTagAsBoolImmediate(X86Assembler::RegisterID reg)
+{
+    m_jit.shl_i8r(JSImmediate::ExtendedPayloadShift, reg);
+    m_jit.orl_i32r(JSImmediate::FullTagTypeBool, reg);
+}
+
 CTI::CTI(Machine* machine, ExecState* exec, CodeBlock* codeBlock)
     : m_jit(machine->jitCodeBuffer())
@@ -1375 +1381 @@
         CTI_COMPILE_UNARY_OP(op_is_object)
         CTI_COMPILE_UNARY_OP(op_is_function)
-        CTI_COMPILE_BINARY_OP(op_stricteq)
         CTI_COMPILE_BINARY_OP(op_nstricteq)
+        case op_stricteq: {
+            unsigned dst = instruction[i + 1].u.operand;
+            unsigned src1 = instruction[i + 2].u.operand;
+            unsigned src2 = instruction[i + 3].u.operand;
+
+            emitGetArg(src1, X86::eax);
+            emitGetArg(src2, X86::edx);
+
+            m_jit.testl_i32r(JSImmediate::TagMask, X86::eax);
+            X86Assembler::JmpSrc firstNotImmediate = m_jit.emitUnlinkedJe();
+            m_jit.testl_i32r(JSImmediate::TagMask, X86::edx);
+            X86Assembler::JmpSrc secondNotImmediate = m_jit.emitUnlinkedJe();
+
+            m_jit.cmpl_rr(X86::edx, X86::eax);
+            m_jit.sete_r(X86::eax);
+            m_jit.movzbl_rr(X86::eax, X86::eax);
+            emitTagAsBoolImmediate(X86::eax);
+            
+            X86Assembler::JmpSrc bothWereImmediates = m_jit.emitUnlinkedJmp();
+
+            m_jit.link(firstNotImmediate, m_jit.label());
+
+            // check that edx is immediate but not the zero immediate
+            
+            m_jit.testl_i32r(JSImmediate::TagMask, X86::edx);
+            m_jit.setz_r(X86::ecx);
+            m_jit.movzbl_rr(X86::ecx, X86::ecx); // ecx is now 1 if edx was nonimmediate
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), X86::edx);
+            m_jit.sete_r(X86::edx);
+            m_jit.movzbl_rr(X86::edx, X86::edx); // edx is now 1 if edx was the 0 immediate
+            m_jit.orl_rr(X86::ecx, X86::edx);
+
+            m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJnz(), i));
+
+            m_jit.movl_i32r(reinterpret_cast<uint32_t>(jsBoolean(false)), X86::eax);
+
+            X86Assembler::JmpSrc firstWasNotImmediate = m_jit.emitUnlinkedJmp();
+
+            m_jit.link(secondNotImmediate, m_jit.label());
+            // check that eax is not the zero immediate (we know it must be immediate)
+            m_jit.cmpl_i32r(reinterpret_cast<uint32_t>(JSImmediate::zeroImmediate()), X86::eax);
+            m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJe(), i));
+
+            m_jit.movl_i32r(reinterpret_cast<uint32_t>(jsBoolean(false)), X86::eax);
+
+            m_jit.link(bothWereImmediates, m_jit.label());
+            m_jit.link(firstWasNotImmediate, m_jit.label());
+
+            emitPutResult(dst);
+            
+            i += 4;
+            break;
+        }
         case op_to_jsnumber: {
             emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
@@ -1973 +2031 @@
             break;
         }
+        CTI_COMPILE_BINARY_OP_SLOW_CASE(op_stricteq);
+
         case op_mod: {
             X86Assembler::JmpSrc notImm1 = iter->from;

trunk/JavaScriptCore/VM/CTI.h

@@ -371 +371 @@
         void emitFastArithIntToImmNoCheck(X86Assembler::RegisterID);
 
+        void emitTagAsBoolImmediate(X86Assembler::RegisterID reg);
+
         void emitDebugExceptionCheck();
 

trunk/JavaScriptCore/VM/Machine.cpp

@@ -5300 +5300 @@
     JSValue* src2 = ARG_src2;
 
-    if (JSImmediate::areBothImmediate(src1, src2))
-        return jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
-    if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
-        return jsBoolean(false);
+    // handled inline as fast cases
+    ASSERT(!JSImmediate::areBothImmediate(src1, src2));
+    ASSERT(!(JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate())));
 
     return jsBoolean(strictEqualSlowCaseInline(src1, src2));