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

Timestamp:

Jan 9, 2009, 12:11:00 AM (16 years ago)

Author:

[email protected]

Message:

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

Reviewed by Oliver Hunt.

Encode immediates in the low word of JSValuePtrs, on x86-64.

On 32-bit platforms a JSValuePtr may represent a 31-bit signed integer.
On 64-bit platforms, if USE(ALTERNATE_JSIMMEDIATE) is defined, a full
32-bit integer may be stored in an immediate.

Presently USE(ALTERNATE_JSIMMEDIATE) uses the same encoding as the default
immediate format - the value is left shifted by one, so a one bit tag can
be added to indicate the value is an immediate. However this means that
values must be commonly be detagged (by right shifting by one) before
arithmetic operations can be performed on immediates. This patch modifies
the formattting so the the high bits of the immediate mark values as being
integer.

• assembler/MacroAssembler.h: (JSC::MacroAssembler::not32): (JSC::MacroAssembler::orPtr): (JSC::MacroAssembler::zeroExtend32ToPtr): (JSC::MacroAssembler::jaePtr): (JSC::MacroAssembler::jbPtr): (JSC::MacroAssembler::jnzPtr): (JSC::MacroAssembler::jzPtr):
• assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::notl_r): (JSC::X86Assembler::testq_i32r):
• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompileCTIMachineTrampolines):
• jit/JIT.h:
• jit/JITArithmetic.cpp: (JSC::JIT::compileFastArith_op_lshift): (JSC::JIT::compileFastArith_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::compileFastArith_op_mul): (JSC::JIT::compileFastArith_op_post_inc): (JSC::JIT::compileFastArith_op_post_dec): (JSC::JIT::compileFastArith_op_pre_inc): (JSC::JIT::compileFastArith_op_pre_dec): (JSC::JIT::putDoubleResultToJSNumberCellOrJSImmediate): (JSC::JIT::compileBinaryArithOp):
• jit/JITCall.cpp: (JSC::JIT::compileOpCallSlowCase):
• jit/JITInlineMethods.h: (JSC::JIT::emitJumpIfJSCell): (JSC::JIT::emitJumpIfNotJSCell): (JSC::JIT::emitJumpIfImmNum): (JSC::JIT::emitJumpSlowCaseIfNotImmNum): (JSC::JIT::emitJumpSlowCaseIfNotImmNums): (JSC::JIT::emitFastArithDeTagImmediate): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::emitFastArithReTagImmediate): (JSC::JIT::emitFastArithImmToInt): (JSC::JIT::emitFastArithIntToImmNoCheck): (JSC::JIT::emitTagAsBoolImmediate):
• jit/JITPropertyAccess.cpp: (JSC::resizePropertyStorage): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdSelf): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdChain): (JSC::JIT::privateCompilePutByIdReplace):
• runtime/JSImmediate.h: (JSC::JSImmediate::isNumber): (JSC::JSImmediate::isPositiveNumber): (JSC::JSImmediate::areBothImmediateNumbers): (JSC::JSImmediate::xorImmediateNumbers): (JSC::JSImmediate::rightShiftImmediateNumbers): (JSC::JSImmediate::canDoFastAdditiveOperations): (JSC::JSImmediate::addImmediateNumbers): (JSC::JSImmediate::subImmediateNumbers): (JSC::JSImmediate::makeInt): (JSC::JSImmediate::toBoolean):
• wtf/Platform.h:

File:

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

trunk/JavaScriptCore/jit/JITInlineMethods.h

@@ -129 +129 @@
 }
 
-ALWAYS_INLINE bool JIT::isOperandConstant31BitImmediateInt(unsigned src)
-{
-    if (!m_codeBlock->isConstantRegisterIndex(src))
-        return false;
-
-    JSValuePtr 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)
@@ -282 +264 @@
 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfJSCell(RegisterID reg)
 {
+#if USE(ALTERNATE_JSIMMEDIATE)
+    return jzPtr(reg, ImmPtr(reinterpret_cast<void*>(JSImmediate::TagMask)));
+#else
     return jz32(reg, Imm32(JSImmediate::TagMask));
+#endif
 }
 
@@ -292 +278 @@
 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotJSCell(RegisterID reg)
 {
+#if USE(ALTERNATE_JSIMMEDIATE)
+    return jnzPtr(reg, ImmPtr(reinterpret_cast<void*>(JSImmediate::TagMask)));
+#else
     return jnz32(reg, Imm32(JSImmediate::TagMask));
+#endif
 }
 
@@ -312 +302 @@
 }
 
+ALWAYS_INLINE JIT::Jump JIT::emitJumpIfImmNum(RegisterID reg)
+{
+#if USE(ALTERNATE_JSIMMEDIATE)
+    return jaePtr(reg, ImmPtr(reinterpret_cast<void*>(JSImmediate::TagTypeInteger)));
+#else
+    return jnz32(reg, Imm32(JSImmediate::TagTypeInteger));
+#endif
+}
+
 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmNum(RegisterID reg)
 {
-    addSlowCase(jz32(reg, Imm32(JSImmediate::TagBitTypeInteger)));
+#if USE(ALTERNATE_JSIMMEDIATE)
+    addSlowCase(jbPtr(reg, ImmPtr(reinterpret_cast<void*>(JSImmediate::TagTypeInteger))));
+#else
+    addSlowCase(jz32(reg, Imm32(JSImmediate::TagTypeInteger)));
+#endif
 }
 
@@ -320 +323 @@
 {
     move(reg1, scratch);
-    and32(reg2, scratch);
+    andPtr(reg2, scratch);
     emitJumpSlowCaseIfNotImmNum(scratch);
 }
 
+#if !USE(ALTERNATE_JSIMMEDIATE)
 ALWAYS_INLINE void JIT::emitFastArithDeTagImmediate(RegisterID reg)
 {
-    subPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
+    subPtr(Imm32(JSImmediate::TagTypeInteger), reg);
 }
 
 ALWAYS_INLINE JIT::Jump JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
 {
-    return jzSubPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
-}
-
-ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID reg)
-{
-    addPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
+    return jzSubPtr(Imm32(JSImmediate::TagTypeInteger), reg);
+}
+#endif
+
+ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID src, RegisterID dest)
+{
+#if USE(ALTERNATE_JSIMMEDIATE)
+    emitFastArithIntToImmNoCheck(src, dest);
+#else
+    if (src != dest)
+        move(src, dest);
+    addPtr(Imm32(JSImmediate::TagTypeInteger), dest);
+#endif
 }
 
 ALWAYS_INLINE void JIT::emitFastArithImmToInt(RegisterID reg)
 {
+#if USE(ALTERNATE_JSIMMEDIATE)
+    UNUSED_PARAM(reg);
+#else
     rshiftPtr(Imm32(JSImmediate::IntegerPayloadShift), reg);
-}
-
-ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID reg)
-{
-    signExtend32ToPtr(reg, reg);
-    addPtr(reg, reg);
-    emitFastArithReTagImmediate(reg);
+#endif
+}
+
+// operand is int32_t, must have been zero-extended if register is 64-bit.
+ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest)
+{
+#if USE(ALTERNATE_JSIMMEDIATE)
+    if (src != dest)
+        move(src, dest);
+    orPtr(ImmPtr(reinterpret_cast<void*>(JSImmediate::TagTypeInteger)), dest);
+#else
+    signExtend32ToPtr(src, dest);
+    addPtr(dest, dest);
+    emitFastArithReTagImmediate(dest, dest);
+#endif
 }
 
@@ -354 +376 @@
 {
     lshift32(Imm32(JSImmediate::ExtendedPayloadShift), reg);
-    or32(Imm32(JSImmediate::FullTagTypeBool), reg);
+    or32(Imm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), reg);
 }