Changeset 39540 in webkit for trunk/JavaScriptCore/jit/JITInlineMethods.h

Timestamp:

Jan 1, 2009, 7:06:10 PM (16 years ago)

Author:

[email protected]

Message:

2009-01-01 Gavin Barraclough <​[email protected]>

Reviewed by Darin Adler.

Allow 32-bit integers to be stored in JSImmediates, on x64-bit.
Presently the top 32-bits of a 64-bit JSImmediate serve as a sign extension of a 31-bit
int stored in the low word (shifted left by one, to make room for a tag). In the new
format, the top 31-bits serve as a sign extension of a 32-bit int, still shifted left by
one.

The new behavior is enabled using a flag in Platform.h, 'WTF_USE_ALTERNATE_JSIMMEDIATE'.
When this is set the constants defining the range of ints allowed to be stored as
JSImmediate values is extended. The code in JSImmediate.h can safely operate on either
format. This patch updates the JIT so that it can also operate with the new format.

~2% progression on x86-64, with & without the JIT, on sunspider & v8 tests.

• assembler/MacroAssembler.h: (JSC::MacroAssembler::addPtr): (JSC::MacroAssembler::orPtr): (JSC::MacroAssembler::or32): (JSC::MacroAssembler::rshiftPtr): (JSC::MacroAssembler::rshift32): (JSC::MacroAssembler::subPtr): (JSC::MacroAssembler::xorPtr): (JSC::MacroAssembler::xor32): (JSC::MacroAssembler::move): (JSC::MacroAssembler::compareImm64ForBranch): (JSC::MacroAssembler::compareImm64ForBranchEquality): (JSC::MacroAssembler::jePtr): (JSC::MacroAssembler::jgePtr): (JSC::MacroAssembler::jlPtr): (JSC::MacroAssembler::jlePtr): (JSC::MacroAssembler::jnePtr): (JSC::MacroAssembler::jnzSubPtr): (JSC::MacroAssembler::joAddPtr): (JSC::MacroAssembler::jzSubPtr):
• assembler/X86Assembler.h: (JSC::X86Assembler::addq_rr): (JSC::X86Assembler::orq_ir): (JSC::X86Assembler::subq_ir): (JSC::X86Assembler::xorq_rr): (JSC::X86Assembler::sarq_CLr): (JSC::X86Assembler::sarq_i8r): (JSC::X86Assembler::cmpq_ir):
• jit/JIT.cpp: (JSC::JIT::compileOpStrictEq): (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompileCTIMachineTrampolines):
• jit/JIT.h:
• jit/JITArithmetic.cpp: (JSC::JIT::compileFastArith_op_lshift): (JSC::JIT::compileFastArithSlow_op_lshift): (JSC::JIT::compileFastArith_op_rshift): (JSC::JIT::compileFastArithSlow_op_rshift): (JSC::JIT::compileFastArith_op_bitand): (JSC::JIT::compileFastArithSlow_op_bitand): (JSC::JIT::compileFastArith_op_mod): (JSC::JIT::compileFastArithSlow_op_mod): (JSC::JIT::compileFastArith_op_add): (JSC::JIT::compileFastArithSlow_op_add): (JSC::JIT::compileFastArith_op_mul): (JSC::JIT::compileFastArithSlow_op_mul): (JSC::JIT::compileFastArith_op_post_inc): (JSC::JIT::compileFastArithSlow_op_post_inc): (JSC::JIT::compileFastArith_op_post_dec): (JSC::JIT::compileFastArithSlow_op_post_dec): (JSC::JIT::compileFastArith_op_pre_inc): (JSC::JIT::compileFastArithSlow_op_pre_inc): (JSC::JIT::compileFastArith_op_pre_dec): (JSC::JIT::compileFastArithSlow_op_pre_dec): (JSC::JIT::compileBinaryArithOp):
• jit/JITInlineMethods.h: (JSC::JIT::getConstantOperand): (JSC::JIT::getConstantOperandImmediateInt): (JSC::JIT::isOperandConstantImmediateInt): (JSC::JIT::isOperandConstant31BitImmediateInt): (JSC::JIT::emitFastArithDeTagImmediate): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::emitFastArithReTagImmediate): (JSC::JIT::emitFastArithImmToInt): (JSC::JIT::emitFastArithIntToImmNoCheck):
• runtime/JSImmediate.h: (JSC::JSImmediate::isPositiveNumber): (JSC::JSImmediate::isNegative): (JSC::JSImmediate::rightShiftImmediateNumbers): (JSC::JSImmediate::canDoFastAdditiveOperations): (JSC::JSImmediate::makeValue): (JSC::JSImmediate::makeInt): (JSC::JSImmediate::makeBool): (JSC::JSImmediate::intValue): (JSC::JSImmediate::rawValue): (JSC::JSImmediate::toBoolean): (JSC::JSImmediate::from):
• wtf/Platform.h:

File:

• trunk/JavaScriptCore/jit/JITInlineMethods.h (modified) (3 diffs)

trunk/JavaScriptCore/jit/JITInlineMethods.h

@@ -42 +42 @@
 namespace JSC {
 
-static ALWAYS_INLINE uintptr_t asInteger(JSValue* value)
-{
-    return reinterpret_cast<uintptr_t>(value);
-}
-
 ALWAYS_INLINE void JIT::killLastResultRegister()
 {
@@ -127 +122 @@
 }
 
+ALWAYS_INLINE JSValue* JIT::getConstantOperand(unsigned src)
+{
+    ASSERT(m_codeBlock->isConstantRegisterIndex(src));
+    return m_codeBlock->getConstant(src);
+}
+
+ALWAYS_INLINE int32_t JIT::getConstantOperandImmediateInt(unsigned src)
+{
+    return static_cast<int32_t>(JSImmediate::intValue(getConstantOperand(src)));
+}
+
+ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(unsigned src)
+{
+    return m_codeBlock->isConstantRegisterIndex(src) && JSImmediate::isNumber(getConstantOperand(src));
+}
+
+ALWAYS_INLINE bool JIT::isOperandConstant31BitImmediateInt(unsigned src)
+{
+    if (!m_codeBlock->isConstantRegisterIndex(src))
+        return false;
+
+    JSValue* value = getConstantOperand(src);
+
+#if USE(ALTERNATE_JSIMMEDIATE)
+    if (!JSImmediate::isNumber(value))
+        return false;
+
+    int32_t imm = JSImmediate::intValue(value);
+    return (imm == ((imm << 1) >> 1));
+#else
+    return JSImmediate::isNumber(value);
+#endif
+}
+
 // get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function.
 ALWAYS_INLINE void JIT::emitPutJITStubArgFromVirtualRegister(unsigned src, unsigned argumentNumber, RegisterID scratch)
@@ -304 +333 @@
 }
 
-ALWAYS_INLINE unsigned JIT::getDeTaggedConstantImmediate(JSValue* imm)
-{
-    ASSERT(JSImmediate::isNumber(imm));
-    return asInteger(imm) & ~JSImmediate::TagBitTypeInteger;
-}
-
 ALWAYS_INLINE void JIT::emitFastArithDeTagImmediate(RegisterID reg)
 {
-    sub32(Imm32(JSImmediate::TagBitTypeInteger), reg);
+    subPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
 }
 
 ALWAYS_INLINE JIT::Jump JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
 {
-    return jzSub32(Imm32(JSImmediate::TagBitTypeInteger), reg);
+    return jzSubPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
 }
 
 ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID reg)
 {
-    add32(Imm32(JSImmediate::TagBitTypeInteger), reg);
+    addPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
+}
+
+ALWAYS_INLINE void JIT::emitFastArithImmToInt(RegisterID reg)
+{
+    rshiftPtr(Imm32(JSImmediate::IntegerPayloadShift), reg);
+}
+
+ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID reg)
+{
     signExtend32ToPtr(reg, reg);
-}
-
-ALWAYS_INLINE void JIT::emitFastArithPotentiallyReTagImmediate(RegisterID reg)
-{
-    or32(Imm32(JSImmediate::TagBitTypeInteger), reg);
-    signExtend32ToPtr(reg, reg);
-}
-
-ALWAYS_INLINE void JIT::emitFastArithImmToInt(RegisterID reg)
-{
-    rshift32(Imm32(JSImmediate::IntegerPayloadShift), reg);
-}
-
-ALWAYS_INLINE void JIT::emitFastArithIntToImmOrSlowCase(RegisterID reg)
-{
-    addSlowCase(joAdd32(reg, reg));
-    emitFastArithReTagImmediate(reg);
-}
-
-ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID reg)
-{
-    add32(reg, reg);
+    addPtr(reg, reg);
     emitFastArithReTagImmediate(reg);
 }