Changeset 191905 in webkit

Timestamp:

Nov 2, 2015 1:10:36 PM (8 years ago)

Author:

mark.lam@apple.com

Message:

Snippefy op_add for the baseline JIT.
​https://bugs.webkit.org/show_bug.cgi?id=150129

Reviewed by Geoffrey Garen and Saam Barati.

Performance is neutral for both 32-bit and 64-bit on X86_64.

• CMakeLists.txt:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
• JavaScriptCore.xcodeproj/project.pbxproj:
• jit/JIT.h:

(JSC::JIT::getOperandConstantInt):

• Move getOperandConstantInt() from the JSVALUE64 section to the common section because the snippet needs it.

• jit/JITAddGenerator.cpp: Added.

(JSC::JITAddGenerator::generateFastPath):

• jit/JITAddGenerator.h: Added.

(JSC::JITAddGenerator::JITAddGenerator):
(JSC::JITAddGenerator::endJumpList):
(JSC::JITAddGenerator::slowPathJumpList):

• JITAddGenerator implements an optimization for the case where 1 of the 2 operands is a constant int32_t. It does not implement an optimization for the case where both operands are constant int32_t. This is because:
  1. For the baseline JIT, the ASTBuilder will fold the 2 constants together.
  2. For the DFG, the AbstractInterpreter will also fold the 2 constants.

Hence, such an optimization path (for 2 constant int32_t operands) would never
be taken, and is why we won't implement it.

• jit/JITArithmetic.cpp:

(JSC::JIT::compileBinaryArithOp):
(JSC::JIT::compileBinaryArithOpSlowCase):

• Removed op_add cases. These are no longer used by the op_add emitters.

(JSC::JIT::emit_op_add):
(JSC::JIT::emitSlow_op_add):

• Moved out from the JSVALUE64 section to the common section, and reimplemented using the snippet.

• jit/JITArithmetic32_64.cpp:

(JSC::JIT::emitBinaryDoubleOp):
(JSC::JIT::emit_op_add): Deleted.
(JSC::JIT::emitAdd32Constant): Deleted.
(JSC::JIT::emitSlow_op_add): Deleted.

• Remove 32-bit specific version of op_add. The snippet serves both 32-bit and 64-bit implementations.

• jit/JITInlines.h:

(JSC::JIT::getOperandConstantInt):

• Move getOperandConstantInt() from the JSVALUE64 section to the common section because the snippet needs it.

Location:

trunk/Source/JavaScriptCore

Files:

• CMakeLists.txt (modified) (1 diff)
• ChangeLog (modified) (2 diffs)
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj (modified) (2 diffs)
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters (modified) (2 diffs)
• JavaScriptCore.xcodeproj/project.pbxproj (modified) (5 diffs)
• jit/JIT.h (modified) (3 diffs)
• jit/JITAddGenerator.cpp (added)
• jit/JITAddGenerator.h (added)
• jit/JITArithmetic.cpp (modified) (8 diffs)
• jit/JITArithmetic32_64.cpp (modified) (3 diffs)
• jit/JITInlines.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/CMakeLists.txt

@@ -431 +431 @@
     jit/IntrinsicEmitter.cpp
     jit/JIT.cpp
+    jit/JITAddGenerator.cpp
     jit/JITArithmetic.cpp
     jit/JITArithmetic32_64.cpp

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2015-11-02  Mark Lam  <mark.lam@apple.com>
+
+        Snippefy op_add for the baseline JIT.
+        https://bugs.webkit.org/show_bug.cgi?id=150129
+
+        Reviewed by Geoffrey Garen and Saam Barati.
+
+        Performance is neutral for both 32-bit and 64-bit on X86_64.
+
+        * CMakeLists.txt:
+        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
+        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * jit/JIT.h:
+        (JSC::JIT::getOperandConstantInt):
+        - Move getOperandConstantInt() from the JSVALUE64 section to the common section
+          because the snippet needs it.
+
+        * jit/JITAddGenerator.cpp: Added.
+        (JSC::JITAddGenerator::generateFastPath):
+        * jit/JITAddGenerator.h: Added.
+        (JSC::JITAddGenerator::JITAddGenerator):
+        (JSC::JITAddGenerator::endJumpList):
+        (JSC::JITAddGenerator::slowPathJumpList):
+        - JITAddGenerator implements an optimization for the case where 1 of the 2 operands
+          is a constant int32_t.  It does not implement an optimization for the case where
+          both operands are constant int32_t.  This is because:
+          1. For the baseline JIT, the ASTBuilder will fold the 2 constants together.
+          2. For the DFG, the AbstractInterpreter will also fold the 2 constants.
+
+          Hence, such an optimization path (for 2 constant int32_t operands) would never
+          be taken, and is why we won't implement it.
+
+        * jit/JITArithmetic.cpp:
+        (JSC::JIT::compileBinaryArithOp):
+        (JSC::JIT::compileBinaryArithOpSlowCase):
+        - Removed op_add cases.  These are no longer used by the op_add emitters.
+
+        (JSC::JIT::emit_op_add):
+        (JSC::JIT::emitSlow_op_add):
+        - Moved out from the JSVALUE64 section to the common section, and reimplemented
+          using the snippet.
+
+        * jit/JITArithmetic32_64.cpp:
+        (JSC::JIT::emitBinaryDoubleOp):
+        (JSC::JIT::emit_op_add): Deleted.
+        (JSC::JIT::emitAdd32Constant): Deleted.
+        (JSC::JIT::emitSlow_op_add): Deleted.
+        - Remove 32-bit specific version of op_add.  The snippet serves both 32-bit
+          and 64-bit implementations.
+
+        * jit/JITInlines.h:
+        (JSC::JIT::getOperandConstantInt):
+        - Move getOperandConstantInt() from the JSVALUE64 section to the common section
+          because the snippet needs it.
+
 2015-11-02  Brian Burg  <bburg@apple.com>
 
@@ -3519 +3575 @@
         * jit/GCAwareJITStubRoutine.h:
 
->>>>>>> .r191351
 2015-10-20  Tim Horton  <timothy_horton@apple.com>
 

trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj

@@ -639 +639 @@
     <ClCompile Include="..\jit\IntrinsicEmitter.cpp" />
     <ClCompile Include="..\jit\JIT.cpp" />
+    <ClCompile Include="..\jit\JITAddGenerator.cpp" />
     <ClCompile Include="..\jit\JITArithmetic.cpp" />
     <ClCompile Include="..\jit\JITArithmetic32_64.cpp" />
@@ -1456 +1457 @@
     <ClInclude Include="..\jit\HostCallReturnValue.h" />
     <ClInclude Include="..\jit\JIT.h" />
+    <ClInclude Include="..\jit\JITAddGenerator.h" />
     <ClInclude Include="..\jit\JITCode.h" />
     <ClInclude Include="..\jit\JITCompilationEffort.h" />

trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters

@@ -421 +421 @@
       <Filter>jit</Filter>
     </ClCompile>
+    <ClCompile Include="..\jit\JITAddGenerator.cpp">
+      <Filter>jit</Filter>
+    </ClCompile>
     <ClCompile Include="..\jit\JITArithmetic.cpp">
       <Filter>jit</Filter>
@@ -2491 +2494 @@
     </ClInclude>
     <ClInclude Include="..\jit\JIT.h">
+      <Filter>jit</Filter>
+    </ClInclude>
+    <ClInclude Include="..\jit\JITAddGenerator.h">
       <Filter>jit</Filter>
     </ClInclude>

trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

@@ -1925 +1925 @@
                 FE0D4A061AB8DD0A002F54BF /* ExecutionTimeLimitTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE0D4A041AB8DD0A002F54BF /* ExecutionTimeLimitTest.cpp */; };
                 FE0D4A091ABA2437002F54BF /* GlobalContextWithFinalizerTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE0D4A071ABA2437002F54BF /* GlobalContextWithFinalizerTest.cpp */; };
+                FE1220271BE7F58C0039E6F2 /* JITAddGenerator.h in Headers */ = {isa = PBXBuildFile; fileRef = FE1220261BE7F5640039E6F2 /* JITAddGenerator.h */; settings = {ASSET_TAGS = (); }; };
+                FE1220281BE7F5910039E6F2 /* JITAddGenerator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE1220251BE7F5640039E6F2 /* JITAddGenerator.cpp */; settings = {ASSET_TAGS = (); }; };
                 FE1C0FFD1B193E9800B53FCA /* Exception.h in Headers */ = {isa = PBXBuildFile; fileRef = FE1C0FFC1B193E9800B53FCA /* Exception.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 FE1C0FFF1B194FD100B53FCA /* Exception.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE1C0FFE1B194FD100B53FCA /* Exception.cpp */; };
@@ -4017 +4019 @@
                 FE0D4A071ABA2437002F54BF /* GlobalContextWithFinalizerTest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GlobalContextWithFinalizerTest.cpp; path = API/tests/GlobalContextWithFinalizerTest.cpp; sourceTree = "<group>"; };
                 FE0D4A081ABA2437002F54BF /* GlobalContextWithFinalizerTest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GlobalContextWithFinalizerTest.h; path = API/tests/GlobalContextWithFinalizerTest.h; sourceTree = "<group>"; };
+                FE1220251BE7F5640039E6F2 /* JITAddGenerator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JITAddGenerator.cpp; sourceTree = "<group>"; };
+                FE1220261BE7F5640039E6F2 /* JITAddGenerator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITAddGenerator.h; sourceTree = "<group>"; };
                 FE1C0FFC1B193E9800B53FCA /* Exception.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Exception.h; sourceTree = "<group>"; };
                 FE1C0FFE1B194FD100B53FCA /* Exception.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Exception.cpp; sourceTree = "<group>"; };
@@ -4652 +4656 @@
                                 1429D92D0ED22D7000B89619 /* JIT.cpp */,
                                 1429D92E0ED22D7000B89619 /* JIT.h */,
+                                FE1220251BE7F5640039E6F2 /* JITAddGenerator.cpp */,
+                                FE1220261BE7F5640039E6F2 /* JITAddGenerator.h */,
                                 86A90ECF0EE7D51F00AB350D /* JITArithmetic.cpp */,
                                 A75706DD118A2BCF0057F88F /* JITArithmetic32_64.cpp */,
@@ -7243 +7249 @@
                                 14874AE615EBDE4A002E3587 /* JSScope.h in Headers */,
                                 A7C0C4AC168103020017011D /* JSScriptRefPrivate.h in Headers */,
+                                FE1220271BE7F58C0039E6F2 /* JITAddGenerator.h in Headers */,
                                 0F919D11157F332C004A4E7D /* JSSegmentedVariableObject.h in Headers */,
                                 A7299D9E17D12837005F5FF9 /* JSSet.h in Headers */,
@@ -8297 +8304 @@
                                 0F898F311B27689F0083A33C /* DFGIntegerRangeOptimizationPhase.cpp in Sources */,
                                 0FC97F3D18202119002C9B26 /* DFGInvalidationPointInjectionPhase.cpp in Sources */,
+                                FE1220281BE7F5910039E6F2 /* JITAddGenerator.cpp in Sources */,
                                 0FEA0A33170D40BF00BB722C /* DFGJITCode.cpp in Sources */,
                                 86EC9DCB1328DF82002B2AD7 /* DFGJITCompiler.cpp in Sources */,

trunk/Source/JavaScriptCore/jit/JIT.h

@@ -404 +404 @@
         void emitPutVirtualRegister(int dst, JSValueRegs src);
 
+        int32_t getOperandConstantInt(int src);
+
 #if USE(JSVALUE32_64)
         bool getOperandConstantInt(int op1, int op2, int& op, int32_t& constant);
@@ -428 +430 @@
 
         // Arithmetic opcode helpers
-        void emitAdd32Constant(int dst, int op, int32_t constant, ResultType opType);
         void emitSub32Constant(int dst, int op, int32_t constant, ResultType opType);
         void emitBinaryDoubleOp(OpcodeID, int dst, int op1, int op2, OperandTypes, JumpList& notInt32Op1, JumpList& notInt32Op2, bool op1IsInRegisters = true, bool op2IsInRegisters = true);
@@ -447 +448 @@
             emitPutVirtualRegister(dst, payload);
         }
-
-        int32_t getOperandConstantInt(int src);
 
         Jump emitJumpIfJSCell(RegisterID);

trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp

@@ -30 +30 @@
 
 #include "CodeBlock.h"
+#include "JITAddGenerator.h"
 #include "JITInlines.h"
 #include "JITOperations.h"
@@ -667 +668 @@
     emitJumpSlowCaseIfNotInt(regT0);
     emitJumpSlowCaseIfNotInt(regT1);
-    if (opcodeID == op_add)
-        addSlowCase(branchAdd32(Overflow, regT1, regT0));
-    else {
-        ASSERT(opcodeID == op_mul);
-        if (shouldEmitProfiling()) {
-            // We want to be able to measure if this is taking the slow case just
-            // because of negative zero. If this produces positive zero, then we
-            // don't want the slow case to be taken because that will throw off
-            // speculative compilation.
-            move(regT0, regT2);
-            addSlowCase(branchMul32(Overflow, regT1, regT2));
-            JumpList done;
-            done.append(branchTest32(NonZero, regT2));
-            Jump negativeZero = branch32(LessThan, regT0, TrustedImm32(0));
-            done.append(branch32(GreaterThanOrEqual, regT1, TrustedImm32(0)));
-            negativeZero.link(this);
-            // We only get here if we have a genuine negative zero. Record this,
-            // so that the speculative JIT knows that we failed speculation
-            // because of a negative zero.
-            add32(TrustedImm32(1), AbsoluteAddress(&m_codeBlock->addSpecialFastCaseProfile(m_bytecodeOffset)->m_counter));
-            addSlowCase(jump());
-            done.link(this);
-            move(regT2, regT0);
-        } else {
-            addSlowCase(branchMul32(Overflow, regT1, regT0));
-            addSlowCase(branchTest32(Zero, regT0));
-        }
+    ASSERT_UNUSED(opcodeID, opcodeID == op_mul);
+    if (shouldEmitProfiling()) {
+        // We want to be able to measure if this is taking the slow case just
+        // because of negative zero. If this produces positive zero, then we
+        // don't want the slow case to be taken because that will throw off
+        // speculative compilation.
+        move(regT0, regT2);
+        addSlowCase(branchMul32(Overflow, regT1, regT2));
+        JumpList done;
+        done.append(branchTest32(NonZero, regT2));
+        Jump negativeZero = branch32(LessThan, regT0, TrustedImm32(0));
+        done.append(branch32(GreaterThanOrEqual, regT1, TrustedImm32(0)));
+        negativeZero.link(this);
+        // We only get here if we have a genuine negative zero. Record this,
+        // so that the speculative JIT knows that we failed speculation
+        // because of a negative zero.
+        add32(TrustedImm32(1), AbsoluteAddress(&m_codeBlock->addSpecialFastCaseProfile(m_bytecodeOffset)->m_counter));
+        addSlowCase(jump());
+        done.link(this);
+        move(regT2, regT0);
+    } else {
+        addSlowCase(branchMul32(Overflow, regT1, regT0));
+        addSlowCase(branchTest32(Zero, regT0));
     }
     emitTagInt(regT0, regT0);
@@ -720 +717 @@
     Label stubFunctionCall(this);
 
-    JITSlowPathCall slowPathCall(this, currentInstruction, opcodeID == op_add ? slow_path_add : slow_path_mul);
+    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_mul);
     slowPathCall.call();
     Jump end = jump();
@@ -764 +761 @@
     }
 
-    if (opcodeID == op_add)
-        addDouble(fpRegT2, fpRegT1);
-    else if (opcodeID == op_mul)
+    if (opcodeID == op_mul)
         mulDouble(fpRegT2, fpRegT1);
     else {
@@ -777 +772 @@
 
     end.link(this);
-}
-
-void JIT::emit_op_add(Instruction* currentInstruction)
-{
-    int result = currentInstruction[1].u.operand;
-    int op1 = currentInstruction[2].u.operand;
-    int op2 = currentInstruction[3].u.operand;
-    OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
-
-    if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_add);
-        slowPathCall.call();
-        return;
-    }
-
-    if (isOperandConstantInt(op1)) {
-        emitGetVirtualRegister(op2, regT0);
-        emitJumpSlowCaseIfNotInt(regT0);
-        addSlowCase(branchAdd32(Overflow, regT0, Imm32(getOperandConstantInt(op1)), regT1));
-        emitTagInt(regT1, regT0);
-    } else if (isOperandConstantInt(op2)) {
-        emitGetVirtualRegister(op1, regT0);
-        emitJumpSlowCaseIfNotInt(regT0);
-        addSlowCase(branchAdd32(Overflow, regT0, Imm32(getOperandConstantInt(op2)), regT1));
-        emitTagInt(regT1, regT0);
-    } else
-        compileBinaryArithOp(op_add, result, op1, op2, types);
-
-    emitPutVirtualRegister(result);
-}
-
-void JIT::emitSlow_op_add(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
-{
-    int result = currentInstruction[1].u.operand;
-    int op1 = currentInstruction[2].u.operand;
-    int op2 = currentInstruction[3].u.operand;
-    OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
-
-    RELEASE_ASSERT(types.first().mightBeNumber() && types.second().mightBeNumber());
-
-    bool op1HasImmediateIntFastCase = isOperandConstantInt(op1);
-    bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase && isOperandConstantInt(op2);
-    compileBinaryArithOpSlowCase(currentInstruction, op_add, iter, result, op1, op2, types, op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
 }
 
@@ -960 +912 @@
 #endif // USE(JSVALUE64)
 
-void JIT::emit_op_sub(Instruction* currentInstruction)
+void JIT::emit_op_add(Instruction* currentInstruction)
 {
     int result = currentInstruction[1].u.operand;
@@ -984 +936 @@
     emitGetVirtualRegister(op2, rightRegs);
 
-    JITSubGenerator gen(resultRegs, leftRegs, rightRegs, types.first(), types.second(),
+    bool leftIsConstInt32 = isOperandConstantInt(op1);
+    bool rightIsConstInt32 = isOperandConstantInt(op2);
+    JITAddGenerator::OperandsConstness operandsConstness;
+    int32_t rightConstInt32 = 0;
+    ResultType leftType = types.first();
+    ResultType rightType = types.second();
+
+    ASSERT(!leftIsConstInt32 || !rightIsConstInt32);
+
+    if (leftIsConstInt32) {
+        // JITAddGenerator expects the const value in the right operand.
+        // Let's swap the operands.
+        operandsConstness = JITAddGenerator::RightIsConstInt32;
+        rightConstInt32 = getOperandConstantInt(op1);
+        rightType = types.first();
+        emitGetVirtualRegister(op2, leftRegs);
+        leftType = types.second();
+    } else if (rightIsConstInt32) {
+        operandsConstness = JITAddGenerator::RightIsConstInt32;
+        rightConstInt32 = getOperandConstantInt(op2);
+        emitGetVirtualRegister(op1, leftRegs);
+    } else {
+        operandsConstness = JITAddGenerator::NeitherAreConstInt32;
+        emitGetVirtualRegister(op1, leftRegs);
+        emitGetVirtualRegister(op2, rightRegs);
+    }
+
+    JITAddGenerator gen(resultRegs, leftRegs, rightRegs,
+        operandsConstness, rightConstInt32,
+        leftType, rightType,
         fpRegT0, fpRegT1, scratchGPR, scratchFPR);
 
@@ -994 +975 @@
 }
 
+void JIT::emitSlow_op_add(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    linkAllSlowCasesForBytecodeOffset(m_slowCases, iter, m_bytecodeOffset);
+
+    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_add);
+    slowPathCall.call();
+}
+
+void JIT::emit_op_sub(Instruction* currentInstruction)
+{
+    int result = currentInstruction[1].u.operand;
+    int op1 = currentInstruction[2].u.operand;
+    int op2 = currentInstruction[3].u.operand;
+    OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
+
+#if USE(JSVALUE64)
+    JSValueRegs leftRegs = JSValueRegs(regT0);
+    JSValueRegs rightRegs = JSValueRegs(regT1);
+    JSValueRegs resultRegs = leftRegs;
+    GPRReg scratchGPR = regT2;
+    FPRReg scratchFPR = InvalidFPRReg;
+#else
+    JSValueRegs leftRegs = JSValueRegs(regT1, regT0);
+    JSValueRegs rightRegs = JSValueRegs(regT3, regT2);
+    JSValueRegs resultRegs = leftRegs;
+    GPRReg scratchGPR = regT4;
+    FPRReg scratchFPR = fpRegT2;
+#endif
+
+    emitGetVirtualRegister(op1, leftRegs);
+    emitGetVirtualRegister(op2, rightRegs);
+
+    JITSubGenerator gen(resultRegs, leftRegs, rightRegs, types.first(), types.second(),
+        fpRegT0, fpRegT1, scratchGPR, scratchFPR);
+
+    gen.generateFastPath(*this);
+    gen.endJumpList().link(this);
+    emitPutVirtualRegister(result, resultRegs);
+
+    addSlowCase(gen.slowPathJumpList());
+}
+
 void JIT::emitSlow_op_sub(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {

trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp

@@ -481 +481 @@
 // Addition (+)
 
-void JIT::emit_op_add(Instruction* currentInstruction)
-{
-    int dst = currentInstruction[1].u.operand;
-    int op1 = currentInstruction[2].u.operand;
-    int op2 = currentInstruction[3].u.operand;
-    OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
-
-    if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_add);
-        slowPathCall.call();
-        return;
-    }
-
-    JumpList notInt32Op1;
-    JumpList notInt32Op2;
-
-    int op;
-    int32_t constant;
-    if (getOperandConstantInt(op1, op2, op, constant)) {
-        emitAdd32Constant(dst, op, constant, op == op1 ? types.first() : types.second());
-        return;
-    }
-
-    emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
-    notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
-    notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
-
-    // Int32 case.
-    addSlowCase(branchAdd32(Overflow, regT2, regT0));
-    emitStoreInt32(dst, regT0, (op1 == dst || op2 == dst));
-
-    if (!supportsFloatingPoint()) {
-        addSlowCase(notInt32Op1);
-        addSlowCase(notInt32Op2);
-        return;
-    }
-    Jump end = jump();
-
-    // Double case.
-    emitBinaryDoubleOp(op_add, dst, op1, op2, types, notInt32Op1, notInt32Op2);
-    end.link(this);
-}
-
-void JIT::emitAdd32Constant(int dst, int op, int32_t constant, ResultType opType)
-{
-    // Int32 case.
-    emitLoad(op, regT1, regT2);
-    Jump notInt32 = branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag));
-    addSlowCase(branchAdd32(Overflow, regT2, Imm32(constant), regT0));
-    emitStoreInt32(dst, regT0, (op == dst));
-
-    // Double case.
-    if (!supportsFloatingPoint()) {
-        addSlowCase(notInt32);
-        return;
-    }
-    Jump end = jump();
-
-    notInt32.link(this);
-    if (!opType.definitelyIsNumber())
-        addSlowCase(branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)));
-    move(Imm32(constant), regT2);
-    convertInt32ToDouble(regT2, fpRegT0);
-    emitLoadDouble(op, fpRegT1);
-    addDouble(fpRegT1, fpRegT0);
-    emitStoreDouble(dst, fpRegT0);
-
-    end.link(this);
-}
-
-void JIT::emitSlow_op_add(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
-{
-    int op1 = currentInstruction[2].u.operand;
-    int op2 = currentInstruction[3].u.operand;
-    OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
-
-    RELEASE_ASSERT(types.first().mightBeNumber() && types.second().mightBeNumber());
-
-    int op;
-    int32_t constant;
-    if (getOperandConstantInt(op1, op2, op, constant)) {
-        linkSlowCase(iter); // overflow check
-
-        if (!supportsFloatingPoint())
-            linkSlowCase(iter); // non-sse case
-        else {
-            ResultType opType = op == op1 ? types.first() : types.second();
-            if (!opType.definitelyIsNumber())
-                linkSlowCase(iter); // double check
-        }
-    } else {
-        linkSlowCase(iter); // overflow check
-
-        if (!supportsFloatingPoint()) {
-            linkSlowCase(iter); // int32 check
-            linkSlowCase(iter); // int32 check
-        } else {
-            if (!types.first().definitelyIsNumber())
-                linkSlowCase(iter); // double check
-
-            if (!types.second().definitelyIsNumber()) {
-                linkSlowCase(iter); // int32 check
-                linkSlowCase(iter); // double check
-            }
-        }
-    }
-
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_add);
-    slowPathCall.call();
-}
-
-// Subtraction (-)
-
 void JIT::emitBinaryDoubleOp(OpcodeID opcodeID, int dst, int op1, int op2, OperandTypes types, JumpList& notInt32Op1, JumpList& notInt32Op2, bool op1IsInRegisters, bool op2IsInRegisters)
 {
@@ -629 +516 @@
                 emitLoadDouble(op1, fpRegT2);
                 mulDouble(fpRegT2, fpRegT0);
-                emitStoreDouble(dst, fpRegT0);
-                break;
-            case op_add:
-                emitLoadDouble(op1, fpRegT2);
-                addDouble(fpRegT2, fpRegT0);
                 emitStoreDouble(dst, fpRegT0);
                 break;
@@ -725 +607 @@
                 emitLoadDouble(op2, fpRegT2);
                 mulDouble(fpRegT2, fpRegT0);
-                emitStoreDouble(dst, fpRegT0);
-                break;
-            case op_add:
-                emitLoadDouble(op2, fpRegT2);
-                addDouble(fpRegT2, fpRegT0);
                 emitStoreDouble(dst, fpRegT0);
                 break;

trunk/Source/JavaScriptCore/jit/JITInlines.h

@@ -976 +976 @@
 }
 
+ALWAYS_INLINE int32_t JIT::getOperandConstantInt(int src)
+{
+    return getConstantOperand(src).asInt32();
+}
+
 #if USE(JSVALUE32_64)
 
@@ -1193 +1198 @@
 }
 
-ALWAYS_INLINE int32_t JIT::getOperandConstantInt(int src)
-{
-    return getConstantOperand(src).asInt32();
-}
-
 ALWAYS_INLINE bool JIT::isOperandConstantInt(int src)
 {