Changeset 58562 in webkit for trunk/JavaScriptCore/jit/JITArithmetic32_64.cpp

Timestamp:

Apr 30, 2010, 12:56:38 AM (15 years ago)

Author:

[email protected]

Message:

2010-04-29 Oliver Hunt <​[email protected]>

Reviewed by Gavin Barraclough.

Add codegen support for unsigned right shift
​https://bugs.webkit.org/show_bug.cgi?id=38375

Expose unsigned right shift in the macro assembler, and make use of it
from the jit. Currently if the result is outside the range 0..2^{31-1
we simply fall back to the slow case, even in JSVALUE64 and JSVALUE32_64
where technically we could still return an immediate value.}

• assembler/MacroAssemblerARM.h: (JSC::MacroAssemblerARM::urshift32):
• assembler/MacroAssemblerARMv7.h: (JSC::MacroAssemblerARMv7::urshift32):
• assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::urshift32):
• assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::shrl_i8r): (JSC::X86Assembler::shrl_CLr):

Add unsigned right shift to the x86 assembler

• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases):

op_rshift no longer simply get thrown to a stub function

• jit/JIT.h:
• jit/JITArithmetic.cpp: (JSC::JIT::emit_op_urshift): (JSC::JIT::emitSlow_op_urshift): JSVALUE32 and JSVALUE64 implementation. Only supports double lhs in JSVALUE64.
• jit/JITArithmetic32_64.cpp: (JSC::JIT::emit_op_rshift): (JSC::JIT::emitSlow_op_rshift): (JSC::JIT::emit_op_urshift): (JSC::JIT::emitSlow_op_urshift): Refactor right shift code to have shared implementation between signed and unsigned versions.

File:

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

trunk/JavaScriptCore/jit/JITArithmetic32_64.cpp

@@ -315 +315 @@
 }
 
-// RightShift (>>)
-
-void JIT::emit_op_rshift(Instruction* currentInstruction)
+// RightShift (>>) and UnsignedRightShift (>>>) helper
+
+void JIT::emitRightShift(Instruction* currentInstruction, bool isUnsigned)
 {
     unsigned dst = currentInstruction[1].u.operand;
@@ -328 +328 @@
         emitLoad(op1, regT1, regT0);
         addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
-        rshift32(Imm32(getConstantOperand(op2).asInt32()), regT0);
+        int shift = getConstantOperand(op2).asInt32();
+        if (isUnsigned) {
+            if (shift)
+                urshift32(Imm32(shift & 0x1f), regT0);
+            // unsigned shift < 0 or shift = k*2^32 may result in (essentially)
+            // a toUint conversion, which can result in a value we can represent
+            // as an immediate int.
+            if (shift < 0 || !(shift & 31))
+                addSlowCase(branch32(LessThan, regT0, Imm32(0)));
+        } else if (shift) { // signed right shift by zero is simply toInt conversion
+            rshift32(Imm32(shift & 0x1f), regT0);
+        }
         emitStoreInt32(dst, regT0, dst == op1);
         return;
@@ -337 +348 @@
         addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
     addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
-    rshift32(regT2, regT0);
+    if (isUnsigned) {
+        urshift32(regT2, regT0);
+        addSlowCase(branch32(LessThan, regT0, Imm32(0)));
+    } else
+        rshift32(regT2, regT0);
     emitStoreInt32(dst, regT0, dst == op1 || dst == op2);
 }
 
-void JIT::emitSlow_op_rshift(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+void JIT::emitRightShiftSlowCase(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter, bool isUnsigned)
 {
     unsigned dst = currentInstruction[1].u.operand;
@@ -347 +362 @@
     unsigned op2 = currentInstruction[3].u.operand;
     if (isOperandConstantImmediateInt(op2)) {
+        int shift = getConstantOperand(op2).asInt32();
         // op1 = regT1:regT0
         linkSlowCase(iter); // int32 check
         if (supportsFloatingPointTruncate()) {
-            Jump notDouble = branch32(AboveOrEqual, regT1, Imm32(JSValue::LowestTag));
+            JumpList failures;
+            failures.append(branch32(AboveOrEqual, regT1, Imm32(JSValue::LowestTag)));
             emitLoadDouble(op1, fpRegT0);
-            Jump truncationFailed = branchTruncateDoubleToInt32(fpRegT0, regT0);
-            rshift32(Imm32(getConstantOperand(op2).asInt32()), regT0);
+            failures.append(branchTruncateDoubleToInt32(fpRegT0, regT0));
+            if (isUnsigned) {
+                if (shift)
+                    urshift32(Imm32(shift & 0x1f), regT0);
+                if (shift < 0 || !(shift & 31))
+                    failures.append(branch32(LessThan, regT0, Imm32(0)));
+            } else if (shift)
+                rshift32(Imm32(shift & 0x1f), regT0);
             emitStoreInt32(dst, regT0, dst == op1 || dst == op2);
             emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_rshift));
-            notDouble.link(this);
-            truncationFailed.link(this);
+            failures.link(this);
         }
+        if (isUnsigned && (shift < 0 || !(shift & 31)))
+            linkSlowCase(iter); // failed to box in hot path
     } else {
         // op1 = regT1:regT0
@@ -369 +393 @@
                 Jump notInt = branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)); // op2 is not an int
                 Jump cantTruncate = branchTruncateDoubleToInt32(fpRegT0, regT0);
-                rshift32(regT2, regT0);
+                if (isUnsigned)
+                    urshift32(regT2, regT0);
+                else
+                    rshift32(regT2, regT0);
                 emitStoreInt32(dst, regT0, dst == op1 || dst == op2);
                 emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_rshift));
@@ -379 +406 @@
 
         linkSlowCase(iter); // int32 check - op2 is not an int
-    }
-
-    JITStubCall stubCall(this, cti_op_rshift);
-    stubCall.addArgument(op1);
-    stubCall.addArgument(op2);
-    stubCall.call(dst);
+        if (isUnsigned)
+            linkSlowCase(iter); // Can't represent unsigned result as an immediate
+    }
+
+    JITStubCall stubCall(this, isUnsigned ? cti_op_urshift : cti_op_rshift);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
+}
+
+// RightShift (>>)
+
+void JIT::emit_op_rshift(Instruction* currentInstruction)
+{
+    emitRightShift(currentInstruction, false);
+}
+
+void JIT::emitSlow_op_rshift(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    emitRightShiftSlowCase(currentInstruction, iter, false);
+}
+
+// UnsignedRightShift (>>>)
+
+void JIT::emit_op_urshift(Instruction* currentInstruction)
+{
+    emitRightShift(currentInstruction, true);
+}
+
+void JIT::emitSlow_op_urshift(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    emitRightShiftSlowCase(currentInstruction, iter, true);
 }