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

Timestamp:

May 7, 2009, 1:42:59 PM (16 years ago)

Author:

[email protected]

Message:

2009-05-07 Maciej Stachowiak <​[email protected]>

Reviewed by Sam Weinig.

• optimize various cases of branch-fused less

1% speedup on SunSpider overall
13% speedup on math-cordic

• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): op_loop_if_less: Optimize case of constant as first operand, just as case of constant as second operand. op_jnless: Factored out into compileFastArith_op_jnless. (JSC::JIT::privateCompileSlowCases): op_jnless: Factored out into compileFastArithSlow_op_jnless.
• jit/JIT.h:
• jit/JITArithmetic.cpp: (JSC::JIT::compileFastArith_op_jnless): Factored out from main compile loop.
• Generate inline code for comparison of constant immediate int as first operand to another immediate int, as for loop_if_less

(JSC::JIT::compileFastArithSlow_op_jnless):

• Generate inline code for comparing two floating point numbers.
• Generate code for both cases of comparing a floating point number to a constant immediate int.
• bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): Fix dumping of op_jnless (tangentially related bugfix).

File:

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

trunk/JavaScriptCore/jit/JIT.cpp

@@ +1 @@
+
 /*
  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
@@ -229 +230 @@
 #endif
                 addJump(branch32(LessThan, regT0, Imm32(op2imm)), target + 3);
+            } else if (isOperandConstantImmediateInt(op1)) {
+                emitGetVirtualRegister(op2, regT1);
+                emitJumpSlowCaseIfNotImmediateInteger(regT1);
+#if USE(ALTERNATE_JSIMMEDIATE)
+                int32_t op1imm = getConstantOperandImmediateInt(op1);
+#else
+                int32_t op1imm = static_cast<int32_t>(JSImmediate::rawValue(getConstantOperand(op1)));
+#endif
+                addJump(branch32(GreaterThan, regT1, Imm32(op1imm)), target + 3);
             } else {
                 emitGetVirtualRegisters(op1, regT0, op2, regT1);
@@ -614 +624 @@
         }
         case op_jnless: {
-            unsigned op1 = currentInstruction[1].u.operand;
-            unsigned op2 = currentInstruction[2].u.operand;
             unsigned target = currentInstruction[3].u.operand;
-            if (isOperandConstantImmediateInt(op2)) {
-                emitGetVirtualRegister(op1, regT0);
-                emitJumpSlowCaseIfNotImmediateInteger(regT0);
-#if USE(ALTERNATE_JSIMMEDIATE)
-                int32_t op2imm = getConstantOperandImmediateInt(op2);
-#else
-                int32_t op2imm = static_cast<int32_t>(JSImmediate::rawValue(getConstantOperand(op2)));
-#endif
-                addJump(branch32(GreaterThanOrEqual, regT0, Imm32(op2imm)), target + 3);
-            } else {
-                emitGetVirtualRegisters(op1, regT0, op2, regT1);
-                emitJumpSlowCaseIfNotImmediateInteger(regT0);
-                emitJumpSlowCaseIfNotImmediateInteger(regT1);
-                addJump(branch32(GreaterThanOrEqual, regT0, regT1), target + 3);
-            }
+            compileFastArith_op_jnless(currentInstruction[1].u.operand, currentInstruction[2].u.operand, target);
             RECORD_JUMP_TARGET(target + 3);
             NEXT_OPCODE(op_jnless);
@@ -1236 +1230 @@
         }
         case op_loop_if_less: {
+            unsigned op1 = currentInstruction[1].u.operand;
             unsigned op2 = currentInstruction[2].u.operand;
             unsigned target = currentInstruction[3].u.operand;
@@ -1242 +1237 @@
                 emitPutJITStubArg(regT0, 1);
                 emitPutJITStubArgFromVirtualRegister(op2, 2, regT2);
+                emitCTICall(JITStubs::cti_op_loop_if_less);
+                emitJumpSlowToHot(branchTest32(NonZero, regT0), target + 3);
+            } else if (isOperandConstantImmediateInt(op1)) {
+                linkSlowCase(iter);
+                emitPutJITStubArgFromVirtualRegister(op1, 1, regT1);
+                emitPutJITStubArg(regT0, 2);
                 emitCTICall(JITStubs::cti_op_loop_if_less);
                 emitJumpSlowToHot(branchTest32(NonZero, regT0), target + 3);
@@ -1323 +1324 @@
         }
         case op_jnless: {
-            unsigned op2 = currentInstruction[2].u.operand;
-            unsigned target = currentInstruction[3].u.operand;
-            if (isOperandConstantImmediateInt(op2)) {
-                linkSlowCase(iter);
-                emitPutJITStubArg(regT0, 1);
-                emitPutJITStubArgFromVirtualRegister(currentInstruction[2].u.operand, 2, regT2);
-                emitCTICall(JITStubs::cti_op_jless);
-                emitJumpSlowToHot(branchTest32(Zero, regT0), target + 3);
-            } else {
-                linkSlowCase(iter);
-                linkSlowCase(iter);
-                emitPutJITStubArg(regT0, 1);
-                emitPutJITStubArg(regT1, 2);
-                emitCTICall(JITStubs::cti_op_jless);
-                emitJumpSlowToHot(branchTest32(Zero, regT0), target + 3);
-            }
+            compileFastArithSlow_op_jnless(currentInstruction[1].u.operand, currentInstruction[2].u.operand, currentInstruction[3].u.operand, iter);
             NEXT_OPCODE(op_jnless);
         }