Ignore:
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:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/JavaScriptCore/jit/JITInlineMethods.h

    r39428 r39540  
    4242namespace JSC {
    4343
    44 static ALWAYS_INLINE uintptr_t asInteger(JSValue* value)
    45 {
    46     return reinterpret_cast<uintptr_t>(value);
    47 }
    48 
    4944ALWAYS_INLINE void JIT::killLastResultRegister()
    5045{
     
    127122}
    128123
     124ALWAYS_INLINE JSValue* JIT::getConstantOperand(unsigned src)
     125{
     126    ASSERT(m_codeBlock->isConstantRegisterIndex(src));
     127    return m_codeBlock->getConstant(src);
     128}
     129
     130ALWAYS_INLINE int32_t JIT::getConstantOperandImmediateInt(unsigned src)
     131{
     132    return static_cast<int32_t>(JSImmediate::intValue(getConstantOperand(src)));
     133}
     134
     135ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(unsigned src)
     136{
     137    return m_codeBlock->isConstantRegisterIndex(src) && JSImmediate::isNumber(getConstantOperand(src));
     138}
     139
     140ALWAYS_INLINE bool JIT::isOperandConstant31BitImmediateInt(unsigned src)
     141{
     142    if (!m_codeBlock->isConstantRegisterIndex(src))
     143        return false;
     144
     145    JSValue* value = getConstantOperand(src);
     146
     147#if USE(ALTERNATE_JSIMMEDIATE)
     148    if (!JSImmediate::isNumber(value))
     149        return false;
     150
     151    int32_t imm = JSImmediate::intValue(value);
     152    return (imm == ((imm << 1) >> 1));
     153#else
     154    return JSImmediate::isNumber(value);
     155#endif
     156}
     157
    129158// get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function.
    130159ALWAYS_INLINE void JIT::emitPutJITStubArgFromVirtualRegister(unsigned src, unsigned argumentNumber, RegisterID scratch)
     
    304333}
    305334
    306 ALWAYS_INLINE unsigned JIT::getDeTaggedConstantImmediate(JSValue* imm)
    307 {
    308     ASSERT(JSImmediate::isNumber(imm));
    309     return asInteger(imm) & ~JSImmediate::TagBitTypeInteger;
    310 }
    311 
    312335ALWAYS_INLINE void JIT::emitFastArithDeTagImmediate(RegisterID reg)
    313336{
    314     sub32(Imm32(JSImmediate::TagBitTypeInteger), reg);
     337    subPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
    315338}
    316339
    317340ALWAYS_INLINE JIT::Jump JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
    318341{
    319     return jzSub32(Imm32(JSImmediate::TagBitTypeInteger), reg);
     342    return jzSubPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
    320343}
    321344
    322345ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID reg)
    323346{
    324     add32(Imm32(JSImmediate::TagBitTypeInteger), reg);
     347    addPtr(Imm32(JSImmediate::TagBitTypeInteger), reg);
     348}
     349
     350ALWAYS_INLINE void JIT::emitFastArithImmToInt(RegisterID reg)
     351{
     352    rshiftPtr(Imm32(JSImmediate::IntegerPayloadShift), reg);
     353}
     354
     355ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID reg)
     356{
    325357    signExtend32ToPtr(reg, reg);
    326 }
    327 
    328 ALWAYS_INLINE void JIT::emitFastArithPotentiallyReTagImmediate(RegisterID reg)
    329 {
    330     or32(Imm32(JSImmediate::TagBitTypeInteger), reg);
    331     signExtend32ToPtr(reg, reg);
    332 }
    333 
    334 ALWAYS_INLINE void JIT::emitFastArithImmToInt(RegisterID reg)
    335 {
    336     rshift32(Imm32(JSImmediate::IntegerPayloadShift), reg);
    337 }
    338 
    339 ALWAYS_INLINE void JIT::emitFastArithIntToImmOrSlowCase(RegisterID reg)
    340 {
    341     addSlowCase(joAdd32(reg, reg));
    342     emitFastArithReTagImmediate(reg);
    343 }
    344 
    345 ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID reg)
    346 {
    347     add32(reg, reg);
     358    addPtr(reg, reg);
    348359    emitFastArithReTagImmediate(reg);
    349360}
Note: See TracChangeset for help on using the changeset viewer.