Home | History | Annotate | Download | only in jit 
      1 /*
      2  * Copyright (C) 2008 Apple Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #ifndef JITInlineMethods_h
     27 #define JITInlineMethods_h
     28 
     29 #include <wtf/Platform.h>
     30 
     31 #if ENABLE(JIT)
     32 
     33 namespace JSC {
     34 
     35 /* Deprecated: Please use JITStubCall instead. */
     36 
     37 // puts an arg onto the stack, as an arg to a context threaded function.
     38 ALWAYS_INLINE void JIT::emitPutJITStubArg(RegisterID src, unsigned argumentNumber)
     39 {
     40     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
     41     poke(src, argumentStackOffset);
     42 }
     43 
     44 /* Deprecated: Please use JITStubCall instead. */
     45 
     46 ALWAYS_INLINE void JIT::emitPutJITStubArgConstant(unsigned value, unsigned argumentNumber)
     47 {
     48     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
     49     poke(Imm32(value), argumentStackOffset);
     50 }
     51 
     52 /* Deprecated: Please use JITStubCall instead. */
     53 
     54 ALWAYS_INLINE void JIT::emitPutJITStubArgConstant(void* value, unsigned argumentNumber)
     55 {
     56     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
     57     poke(ImmPtr(value), argumentStackOffset);
     58 }
     59 
     60 /* Deprecated: Please use JITStubCall instead. */
     61 
     62 ALWAYS_INLINE void JIT::emitGetJITStubArg(unsigned argumentNumber, RegisterID dst)
     63 {
     64     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
     65     peek(dst, argumentStackOffset);
     66 }
     67 
     68 ALWAYS_INLINE bool JIT::isOperandConstantImmediateDouble(unsigned src)
     69 {
     70     return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isDouble();
     71 }
     72 
     73 ALWAYS_INLINE JSValue JIT::getConstantOperand(unsigned src)
     74 {
     75     ASSERT(m_codeBlock->isConstantRegisterIndex(src));
     76     return m_codeBlock->getConstant(src);
     77 }
     78 
     79 ALWAYS_INLINE void JIT::emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
     80 {
     81     storePtr(from, Address(callFrameRegister, entry * sizeof(Register)));
     82 }
     83 
     84 ALWAYS_INLINE void JIT::emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)
     85 {
     86     storePtr(ImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
     87 }
     88 
     89 ALWAYS_INLINE void JIT::emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
     90 {
     91     loadPtr(Address(from, entry * sizeof(Register)), to);
     92 #if !USE(JSVALUE32_64)
     93     killLastResultRegister();
     94 #endif
     95 }
     96 
     97 ALWAYS_INLINE void JIT::emitGetFromCallFrameHeader32(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
     98 {
     99     load32(Address(from, entry * sizeof(Register)), to);
    100 #if !USE(JSVALUE32_64)
    101     killLastResultRegister();
    102 #endif
    103 }
    104 
    105 ALWAYS_INLINE JIT::Call JIT::emitNakedCall(CodePtr function)
    106 {
    107     ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.
    108 
    109     Call nakedCall = nearCall();
    110     m_calls.append(CallRecord(nakedCall, m_bytecodeIndex, function.executableAddress()));
    111     return nakedCall;
    112 }
    113 
    114 #if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL
    115 
    116 ALWAYS_INLINE void JIT::beginUninterruptedSequence(int insnSpace, int constSpace)
    117 {
    118 #if CPU(ARM_TRADITIONAL)
    119 #ifndef NDEBUG
    120     // Ensure the label after the sequence can also fit
    121     insnSpace += sizeof(ARMWord);
    122     constSpace += sizeof(uint64_t);
    123 #endif
    124 
    125     ensureSpace(insnSpace, constSpace);
    126 
    127 #endif
    128 
    129 #if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL
    130 #ifndef NDEBUG
    131     m_uninterruptedInstructionSequenceBegin = label();
    132     m_uninterruptedConstantSequenceBegin = sizeOfConstantPool();
    133 #endif
    134 #endif
    135 }
    136 
    137 ALWAYS_INLINE void JIT::endUninterruptedSequence(int insnSpace, int constSpace)
    138 {
    139 #if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL
    140     ASSERT(differenceBetween(m_uninterruptedInstructionSequenceBegin, label()) == insnSpace);
    141     ASSERT(sizeOfConstantPool() - m_uninterruptedConstantSequenceBegin == constSpace);
    142 #endif
    143 }
    144 
    145 #endif
    146 
    147 #if CPU(ARM)
    148 
    149 ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)
    150 {
    151     move(linkRegister, reg);
    152 }
    153 
    154 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)
    155 {
    156     move(reg, linkRegister);
    157 }
    158 
    159 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)
    160 {
    161     loadPtr(address, linkRegister);
    162 }
    163 
    164 #else // CPU(X86) || CPU(X86_64)
    165 
    166 ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)
    167 {
    168     pop(reg);
    169 }
    170 
    171 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)
    172 {
    173     push(reg);
    174 }
    175 
    176 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)
    177 {
    178     push(address);
    179 }
    180 
    181 #endif
    182 
    183 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
    184 ALWAYS_INLINE void JIT::restoreArgumentReference()
    185 {
    186     poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));
    187 }
    188 ALWAYS_INLINE void JIT::restoreArgumentReferenceForTrampoline() {}
    189 #else
    190 ALWAYS_INLINE void JIT::restoreArgumentReference()
    191 {
    192     move(stackPointerRegister, firstArgumentRegister);
    193     poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));
    194 }
    195 ALWAYS_INLINE void JIT::restoreArgumentReferenceForTrampoline()
    196 {
    197 #if CPU(X86)
    198     // Within a trampoline the return address will be on the stack at this point.
    199     addPtr(Imm32(sizeof(void*)), stackPointerRegister, firstArgumentRegister);
    200 #elif CPU(ARM)
    201     move(stackPointerRegister, firstArgumentRegister);
    202 #endif
    203     // In the trampoline on x86-64, the first argument register is not overwritten.
    204 }
    205 #endif
    206 
    207 ALWAYS_INLINE JIT::Jump JIT::checkStructure(RegisterID reg, Structure* structure)
    208 {
    209     return branchPtr(NotEqual, Address(reg, OBJECT_OFFSETOF(JSCell, m_structure)), ImmPtr(structure));
    210 }
    211 
    212 ALWAYS_INLINE void JIT::linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator& iter, int vReg)
    213 {
    214     if (!m_codeBlock->isKnownNotImmediate(vReg))
    215         linkSlowCase(iter);
    216 }
    217 
    218 ALWAYS_INLINE void JIT::addSlowCase(Jump jump)
    219 {
    220     ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.
    221 
    222     m_slowCases.append(SlowCaseEntry(jump, m_bytecodeIndex));
    223 }
    224 
    225 ALWAYS_INLINE void JIT::addSlowCase(JumpList jumpList)
    226 {
    227     ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.
    228 
    229     const JumpList::JumpVector& jumpVector = jumpList.jumps();
    230     size_t size = jumpVector.size();
    231     for (size_t i = 0; i < size; ++i)
    232         m_slowCases.append(SlowCaseEntry(jumpVector[i], m_bytecodeIndex));
    233 }
    234 
    235 ALWAYS_INLINE void JIT::addJump(Jump jump, int relativeOffset)
    236 {
    237     ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.
    238 
    239     m_jmpTable.append(JumpTable(jump, m_bytecodeIndex + relativeOffset));
    240 }
    241 
    242 ALWAYS_INLINE void JIT::emitJumpSlowToHot(Jump jump, int relativeOffset)
    243 {
    244     ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.
    245 
    246     jump.linkTo(m_labels[m_bytecodeIndex + relativeOffset], this);
    247 }
    248 
    249 #if ENABLE(SAMPLING_FLAGS)
    250 ALWAYS_INLINE void JIT::setSamplingFlag(int32_t flag)
    251 {
    252     ASSERT(flag >= 1);
    253     ASSERT(flag <= 32);
    254     or32(Imm32(1u << (flag - 1)), AbsoluteAddress(&SamplingFlags::s_flags));
    255 }
    256 
    257 ALWAYS_INLINE void JIT::clearSamplingFlag(int32_t flag)
    258 {
    259     ASSERT(flag >= 1);
    260     ASSERT(flag <= 32);
    261     and32(Imm32(~(1u << (flag - 1))), AbsoluteAddress(&SamplingFlags::s_flags));
    262 }
    263 #endif
    264 
    265 #if ENABLE(SAMPLING_COUNTERS)
    266 ALWAYS_INLINE void JIT::emitCount(AbstractSamplingCounter& counter, uint32_t count)
    267 {
    268 #if CPU(X86_64) // Or any other 64-bit plattform.
    269     addPtr(Imm32(count), AbsoluteAddress(&counter.m_counter));
    270 #elif CPU(X86) // Or any other little-endian 32-bit plattform.
    271     intptr_t hiWord = reinterpret_cast<intptr_t>(&counter.m_counter) + sizeof(int32_t);
    272     add32(Imm32(count), AbsoluteAddress(&counter.m_counter));
    273     addWithCarry32(Imm32(0), AbsoluteAddress(reinterpret_cast<void*>(hiWord)));
    274 #else
    275 #error "SAMPLING_FLAGS not implemented on this platform."
    276 #endif
    277 }
    278 #endif
    279 
    280 #if ENABLE(OPCODE_SAMPLING)
    281 #if CPU(X86_64)
    282 ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)
    283 {
    284     move(ImmPtr(m_interpreter->sampler()->sampleSlot()), X86Registers::ecx);
    285     storePtr(ImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), X86Registers::ecx);
    286 }
    287 #else
    288 ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)
    289 {
    290     storePtr(ImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), m_interpreter->sampler()->sampleSlot());
    291 }
    292 #endif
    293 #endif
    294 
    295 #if ENABLE(CODEBLOCK_SAMPLING)
    296 #if CPU(X86_64)
    297 ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)
    298 {
    299     move(ImmPtr(m_interpreter->sampler()->codeBlockSlot()), X86Registers::ecx);
    300     storePtr(ImmPtr(codeBlock), X86Registers::ecx);
    301 }
    302 #else
    303 ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)
    304 {
    305     storePtr(ImmPtr(codeBlock), m_interpreter->sampler()->codeBlockSlot());
    306 }
    307 #endif
    308 #endif
    309 
    310 inline JIT::Address JIT::addressFor(unsigned index, RegisterID base)
    311 {
    312     return Address(base, (index * sizeof(Register)));
    313 }
    314 
    315 #if USE(JSVALUE32_64)
    316 
    317 inline JIT::Address JIT::tagFor(unsigned index, RegisterID base)
    318 {
    319     return Address(base, (index * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.tag));
    320 }
    321 
    322 inline JIT::Address JIT::payloadFor(unsigned index, RegisterID base)
    323 {
    324     return Address(base, (index * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.payload));
    325 }
    326 
    327 inline void JIT::emitLoadTag(unsigned index, RegisterID tag)
    328 {
    329     RegisterID mappedTag;
    330     if (getMappedTag(index, mappedTag)) {
    331         move(mappedTag, tag);
    332         unmap(tag);
    333         return;
    334     }
    335 
    336     if (m_codeBlock->isConstantRegisterIndex(index)) {
    337         move(Imm32(getConstantOperand(index).tag()), tag);
    338         unmap(tag);
    339         return;
    340     }
    341 
    342     load32(tagFor(index), tag);
    343     unmap(tag);
    344 }
    345 
    346 inline void JIT::emitLoadPayload(unsigned index, RegisterID payload)
    347 {
    348     RegisterID mappedPayload;
    349     if (getMappedPayload(index, mappedPayload)) {
    350         move(mappedPayload, payload);
    351         unmap(payload);
    352         return;
    353     }
    354 
    355     if (m_codeBlock->isConstantRegisterIndex(index)) {
    356         move(Imm32(getConstantOperand(index).payload()), payload);
    357         unmap(payload);
    358         return;
    359     }
    360 
    361     load32(payloadFor(index), payload);
    362     unmap(payload);
    363 }
    364 
    365 inline void JIT::emitLoad(const JSValue& v, RegisterID tag, RegisterID payload)
    366 {
    367     move(Imm32(v.payload()), payload);
    368     move(Imm32(v.tag()), tag);
    369 }
    370 
    371 inline void JIT::emitLoad(unsigned index, RegisterID tag, RegisterID payload, RegisterID base)
    372 {
    373     ASSERT(tag != payload);
    374 
    375     if (base == callFrameRegister) {
    376         ASSERT(payload != base);
    377         emitLoadPayload(index, payload);
    378         emitLoadTag(index, tag);
    379         return;
    380     }
    381 
    382     if (payload == base) { // avoid stomping base
    383         load32(tagFor(index, base), tag);
    384         load32(payloadFor(index, base), payload);
    385         return;
    386     }
    387 
    388     load32(payloadFor(index, base), payload);
    389     load32(tagFor(index, base), tag);
    390 }
    391 
    392 inline void JIT::emitLoad2(unsigned index1, RegisterID tag1, RegisterID payload1, unsigned index2, RegisterID tag2, RegisterID payload2)
    393 {
    394     if (isMapped(index1)) {
    395         emitLoad(index1, tag1, payload1);
    396         emitLoad(index2, tag2, payload2);
    397         return;
    398     }
    399     emitLoad(index2, tag2, payload2);
    400     emitLoad(index1, tag1, payload1);
    401 }
    402 
    403 inline void JIT::emitLoadDouble(unsigned index, FPRegisterID value)
    404 {
    405     if (m_codeBlock->isConstantRegisterIndex(index)) {
    406         Register& inConstantPool = m_codeBlock->constantRegister(index);
    407         loadDouble(&inConstantPool, value);
    408     } else
    409         loadDouble(addressFor(index), value);
    410 }
    411 
    412 inline void JIT::emitLoadInt32ToDouble(unsigned index, FPRegisterID value)
    413 {
    414     if (m_codeBlock->isConstantRegisterIndex(index)) {
    415         Register& inConstantPool = m_codeBlock->constantRegister(index);
    416         char* bytePointer = reinterpret_cast<char*>(&inConstantPool);
    417         convertInt32ToDouble(AbsoluteAddress(bytePointer + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), value);
    418     } else
    419         convertInt32ToDouble(payloadFor(index), value);
    420 }
    421 
    422 inline void JIT::emitStore(unsigned index, RegisterID tag, RegisterID payload, RegisterID base)
    423 {
    424     store32(payload, payloadFor(index, base));
    425     store32(tag, tagFor(index, base));
    426 }
    427 
    428 inline void JIT::emitStoreInt32(unsigned index, RegisterID payload, bool indexIsInt32)
    429 {
    430     store32(payload, payloadFor(index, callFrameRegister));
    431     if (!indexIsInt32)
    432         store32(Imm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
    433 }
    434 
    435 inline void JIT::emitStoreInt32(unsigned index, Imm32 payload, bool indexIsInt32)
    436 {
    437     store32(payload, payloadFor(index, callFrameRegister));
    438     if (!indexIsInt32)
    439         store32(Imm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
    440 }
    441 
    442 inline void JIT::emitStoreCell(unsigned index, RegisterID payload, bool indexIsCell)
    443 {
    444     store32(payload, payloadFor(index, callFrameRegister));
    445     if (!indexIsCell)
    446         store32(Imm32(JSValue::CellTag), tagFor(index, callFrameRegister));
    447 }
    448 
    449 inline void JIT::emitStoreBool(unsigned index, RegisterID tag, bool indexIsBool)
    450 {
    451     if (!indexIsBool)
    452         store32(Imm32(0), payloadFor(index, callFrameRegister));
    453     store32(tag, tagFor(index, callFrameRegister));
    454 }
    455 
    456 inline void JIT::emitStoreDouble(unsigned index, FPRegisterID value)
    457 {
    458     storeDouble(value, addressFor(index));
    459 }
    460 
    461 inline void JIT::emitStore(unsigned index, const JSValue constant, RegisterID base)
    462 {
    463     store32(Imm32(constant.payload()), payloadFor(index, base));
    464     store32(Imm32(constant.tag()), tagFor(index, base));
    465 }
    466 
    467 ALWAYS_INLINE void JIT::emitInitRegister(unsigned dst)
    468 {
    469     emitStore(dst, jsUndefined());
    470 }
    471 
    472 inline bool JIT::isLabeled(unsigned bytecodeIndex)
    473 {
    474     for (size_t numberOfJumpTargets = m_codeBlock->numberOfJumpTargets(); m_jumpTargetIndex != numberOfJumpTargets; ++m_jumpTargetIndex) {
    475         unsigned jumpTarget = m_codeBlock->jumpTarget(m_jumpTargetIndex);
    476         if (jumpTarget == bytecodeIndex)
    477             return true;
    478         if (jumpTarget > bytecodeIndex)
    479             return false;
    480     }
    481     return false;
    482 }
    483 
    484 inline void JIT::map(unsigned bytecodeIndex, unsigned virtualRegisterIndex, RegisterID tag, RegisterID payload)
    485 {
    486     if (isLabeled(bytecodeIndex))
    487         return;
    488 
    489     m_mappedBytecodeIndex = bytecodeIndex;
    490     m_mappedVirtualRegisterIndex = virtualRegisterIndex;
    491     m_mappedTag = tag;
    492     m_mappedPayload = payload;
    493 }
    494 
    495 inline void JIT::unmap(RegisterID registerID)
    496 {
    497     if (m_mappedTag == registerID)
    498         m_mappedTag = (RegisterID)-1;
    499     else if (m_mappedPayload == registerID)
    500         m_mappedPayload = (RegisterID)-1;
    501 }
    502 
    503 inline void JIT::unmap()
    504 {
    505     m_mappedBytecodeIndex = (unsigned)-1;
    506     m_mappedVirtualRegisterIndex = (unsigned)-1;
    507     m_mappedTag = (RegisterID)-1;
    508     m_mappedPayload = (RegisterID)-1;
    509 }
    510 
    511 inline bool JIT::isMapped(unsigned virtualRegisterIndex)
    512 {
    513     if (m_mappedBytecodeIndex != m_bytecodeIndex)
    514         return false;
    515     if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)
    516         return false;
    517     return true;
    518 }
    519 
    520 inline bool JIT::getMappedPayload(unsigned virtualRegisterIndex, RegisterID& payload)
    521 {
    522     if (m_mappedBytecodeIndex != m_bytecodeIndex)
    523         return false;
    524     if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)
    525         return false;
    526     if (m_mappedPayload == (RegisterID)-1)
    527         return false;
    528     payload = m_mappedPayload;
    529     return true;
    530 }
    531 
    532 inline bool JIT::getMappedTag(unsigned virtualRegisterIndex, RegisterID& tag)
    533 {
    534     if (m_mappedBytecodeIndex != m_bytecodeIndex)
    535         return false;
    536     if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)
    537         return false;
    538     if (m_mappedTag == (RegisterID)-1)
    539         return false;
    540     tag = m_mappedTag;
    541     return true;
    542 }
    543 
    544 inline void JIT::emitJumpSlowCaseIfNotJSCell(unsigned virtualRegisterIndex)
    545 {
    546     if (!m_codeBlock->isKnownNotImmediate(virtualRegisterIndex))
    547         addSlowCase(branch32(NotEqual, tagFor(virtualRegisterIndex), Imm32(JSValue::CellTag)));
    548 }
    549 
    550 inline void JIT::emitJumpSlowCaseIfNotJSCell(unsigned virtualRegisterIndex, RegisterID tag)
    551 {
    552     if (!m_codeBlock->isKnownNotImmediate(virtualRegisterIndex))
    553         addSlowCase(branch32(NotEqual, tag, Imm32(JSValue::CellTag)));
    554 }
    555 
    556 inline void JIT::linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator& iter, unsigned virtualRegisterIndex)
    557 {
    558     if (!m_codeBlock->isKnownNotImmediate(virtualRegisterIndex))
    559         linkSlowCase(iter);
    560 }
    561 
    562 ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(unsigned src)
    563 {
    564     return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isInt32();
    565 }
    566 
    567 ALWAYS_INLINE bool JIT::getOperandConstantImmediateInt(unsigned op1, unsigned op2, unsigned& op, int32_t& constant)
    568 {
    569     if (isOperandConstantImmediateInt(op1)) {
    570         constant = getConstantOperand(op1).asInt32();
    571         op = op2;
    572         return true;
    573     }
    574 
    575     if (isOperandConstantImmediateInt(op2)) {
    576         constant = getConstantOperand(op2).asInt32();
    577         op = op1;
    578         return true;
    579     }
    580 
    581     return false;
    582 }
    583 
    584 /* Deprecated: Please use JITStubCall instead. */
    585 
    586 ALWAYS_INLINE void JIT::emitPutJITStubArg(RegisterID tag, RegisterID payload, unsigned argumentNumber)
    587 {
    588     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
    589     poke(payload, argumentStackOffset);
    590     poke(tag, argumentStackOffset + 1);
    591 }
    592 
    593 /* Deprecated: Please use JITStubCall instead. */
    594 
    595 ALWAYS_INLINE void JIT::emitPutJITStubArgFromVirtualRegister(unsigned src, unsigned argumentNumber, RegisterID scratch1, RegisterID scratch2)
    596 {
    597     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
    598     if (m_codeBlock->isConstantRegisterIndex(src)) {
    599         JSValue constant = m_codeBlock->getConstant(src);
    600         poke(Imm32(constant.payload()), argumentStackOffset);
    601         poke(Imm32(constant.tag()), argumentStackOffset + 1);
    602     } else {
    603         emitLoad(src, scratch1, scratch2);
    604         poke(scratch2, argumentStackOffset);
    605         poke(scratch1, argumentStackOffset + 1);
    606     }
    607 }
    608 
    609 #else // USE(JSVALUE32_64)
    610 
    611 ALWAYS_INLINE void JIT::killLastResultRegister()
    612 {
    613     m_lastResultBytecodeRegister = std::numeric_limits<int>::max();
    614 }
    615 
    616 // get arg puts an arg from the SF register array into a h/w register
    617 ALWAYS_INLINE void JIT::emitGetVirtualRegister(int src, RegisterID dst)
    618 {
    619     ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.
    620 
    621     // TODO: we want to reuse values that are already in registers if we can - add a register allocator!
    622     if (m_codeBlock->isConstantRegisterIndex(src)) {
    623         JSValue value = m_codeBlock->getConstant(src);
    624         move(ImmPtr(JSValue::encode(value)), dst);
    625         killLastResultRegister();
    626         return;
    627     }
    628 
    629     if (src == m_lastResultBytecodeRegister && m_codeBlock->isTemporaryRegisterIndex(src)) {
    630         bool atJumpTarget = false;
    631         while (m_jumpTargetsPosition < m_codeBlock->numberOfJumpTargets() && m_codeBlock->jumpTarget(m_jumpTargetsPosition) <= m_bytecodeIndex) {
    632             if (m_codeBlock->jumpTarget(m_jumpTargetsPosition) == m_bytecodeIndex)
    633                 atJumpTarget = true;
    634             ++m_jumpTargetsPosition;
    635         }
    636 
    637         if (!atJumpTarget) {
    638             // The argument we want is already stored in eax
    639             if (dst != cachedResultRegister)
    640                 move(cachedResultRegister, dst);
    641             killLastResultRegister();
    642             return;
    643         }
    644     }
    645 
    646     loadPtr(Address(callFrameRegister, src * sizeof(Register)), dst);
    647     killLastResultRegister();
    648 }
    649 
    650 ALWAYS_INLINE void JIT::emitGetVirtualRegisters(int src1, RegisterID dst1, int src2, RegisterID dst2)
    651 {
    652     if (src2 == m_lastResultBytecodeRegister) {
    653         emitGetVirtualRegister(src2, dst2);
    654         emitGetVirtualRegister(src1, dst1);
    655     } else {
    656         emitGetVirtualRegister(src1, dst1);
    657         emitGetVirtualRegister(src2, dst2);
    658     }
    659 }
    660 
    661 ALWAYS_INLINE int32_t JIT::getConstantOperandImmediateInt(unsigned src)
    662 {
    663     return getConstantOperand(src).asInt32();
    664 }
    665 
    666 ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(unsigned src)
    667 {
    668     return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isInt32();
    669 }
    670 
    671 ALWAYS_INLINE void JIT::emitPutVirtualRegister(unsigned dst, RegisterID from)
    672 {
    673     storePtr(from, Address(callFrameRegister, dst * sizeof(Register)));
    674     m_lastResultBytecodeRegister = (from == cachedResultRegister) ? dst : std::numeric_limits<int>::max();
    675 }
    676 
    677 ALWAYS_INLINE void JIT::emitInitRegister(unsigned dst)
    678 {
    679     storePtr(ImmPtr(JSValue::encode(jsUndefined())), Address(callFrameRegister, dst * sizeof(Register)));
    680 }
    681 
    682 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfJSCell(RegisterID reg)
    683 {
    684 #if USE(JSVALUE64)
    685     return branchTestPtr(Zero, reg, tagMaskRegister);
    686 #else
    687     return branchTest32(Zero, reg, Imm32(JSImmediate::TagMask));
    688 #endif
    689 }
    690 
    691 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfBothJSCells(RegisterID reg1, RegisterID reg2, RegisterID scratch)
    692 {
    693     move(reg1, scratch);
    694     orPtr(reg2, scratch);
    695     return emitJumpIfJSCell(scratch);
    696 }
    697 
    698 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfJSCell(RegisterID reg)
    699 {
    700     addSlowCase(emitJumpIfJSCell(reg));
    701 }
    702 
    703 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotJSCell(RegisterID reg)
    704 {
    705 #if USE(JSVALUE64)
    706     return branchTestPtr(NonZero, reg, tagMaskRegister);
    707 #else
    708     return branchTest32(NonZero, reg, Imm32(JSImmediate::TagMask));
    709 #endif
    710 }
    711 
    712 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg)
    713 {
    714     addSlowCase(emitJumpIfNotJSCell(reg));
    715 }
    716 
    717 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg, int vReg)
    718 {
    719     if (!m_codeBlock->isKnownNotImmediate(vReg))
    720         emitJumpSlowCaseIfNotJSCell(reg);
    721 }
    722 
    723 #if USE(JSVALUE64)
    724 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfImmediateNumber(RegisterID reg)
    725 {
    726     return branchTestPtr(NonZero, reg, tagTypeNumberRegister);
    727 }
    728 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotImmediateNumber(RegisterID reg)
    729 {
    730     return branchTestPtr(Zero, reg, tagTypeNumberRegister);
    731 }
    732 
    733 inline void JIT::emitLoadDouble(unsigned index, FPRegisterID value)
    734 {
    735     if (m_codeBlock->isConstantRegisterIndex(index)) {
    736         Register& inConstantPool = m_codeBlock->constantRegister(index);
    737         loadDouble(&inConstantPool, value);
    738     } else
    739         loadDouble(addressFor(index), value);
    740 }
    741 
    742 inline void JIT::emitLoadInt32ToDouble(unsigned index, FPRegisterID value)
    743 {
    744     if (m_codeBlock->isConstantRegisterIndex(index)) {
    745         Register& inConstantPool = m_codeBlock->constantRegister(index);
    746         convertInt32ToDouble(AbsoluteAddress(&inConstantPool), value);
    747     } else
    748         convertInt32ToDouble(addressFor(index), value);
    749 }
    750 #endif
    751 
    752 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfImmediateInteger(RegisterID reg)
    753 {
    754 #if USE(JSVALUE64)
    755     return branchPtr(AboveOrEqual, reg, tagTypeNumberRegister);
    756 #else
    757     return branchTest32(NonZero, reg, Imm32(JSImmediate::TagTypeNumber));
    758 #endif
    759 }
    760 
    761 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotImmediateInteger(RegisterID reg)
    762 {
    763 #if USE(JSVALUE64)
    764     return branchPtr(Below, reg, tagTypeNumberRegister);
    765 #else
    766     return branchTest32(Zero, reg, Imm32(JSImmediate::TagTypeNumber));
    767 #endif
    768 }
    769 
    770 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotImmediateIntegers(RegisterID reg1, RegisterID reg2, RegisterID scratch)
    771 {
    772     move(reg1, scratch);
    773     andPtr(reg2, scratch);
    774     return emitJumpIfNotImmediateInteger(scratch);
    775 }
    776 
    777 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateInteger(RegisterID reg)
    778 {
    779     addSlowCase(emitJumpIfNotImmediateInteger(reg));
    780 }
    781 
    782 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateIntegers(RegisterID reg1, RegisterID reg2, RegisterID scratch)
    783 {
    784     addSlowCase(emitJumpIfNotImmediateIntegers(reg1, reg2, scratch));
    785 }
    786 
    787 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateNumber(RegisterID reg)
    788 {
    789     addSlowCase(emitJumpIfNotImmediateNumber(reg));
    790 }
    791 
    792 #if !USE(JSVALUE64)
    793 ALWAYS_INLINE void JIT::emitFastArithDeTagImmediate(RegisterID reg)
    794 {
    795     subPtr(Imm32(JSImmediate::TagTypeNumber), reg);
    796 }
    797 
    798 ALWAYS_INLINE JIT::Jump JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
    799 {
    800     return branchSubPtr(Zero, Imm32(JSImmediate::TagTypeNumber), reg);
    801 }
    802 #endif
    803 
    804 ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID src, RegisterID dest)
    805 {
    806 #if USE(JSVALUE64)
    807     emitFastArithIntToImmNoCheck(src, dest);
    808 #else
    809     if (src != dest)
    810         move(src, dest);
    811     addPtr(Imm32(JSImmediate::TagTypeNumber), dest);
    812 #endif
    813 }
    814 
    815 ALWAYS_INLINE void JIT::emitFastArithImmToInt(RegisterID reg)
    816 {
    817 #if USE(JSVALUE64)
    818     UNUSED_PARAM(reg);
    819 #else
    820     rshift32(Imm32(JSImmediate::IntegerPayloadShift), reg);
    821 #endif
    822 }
    823 
    824 // operand is int32_t, must have been zero-extended if register is 64-bit.
    825 ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest)
    826 {
    827 #if USE(JSVALUE64)
    828     if (src != dest)
    829         move(src, dest);
    830     orPtr(tagTypeNumberRegister, dest);
    831 #else
    832     signExtend32ToPtr(src, dest);
    833     addPtr(dest, dest);
    834     emitFastArithReTagImmediate(dest, dest);
    835 #endif
    836 }
    837 
    838 ALWAYS_INLINE void JIT::emitTagAsBoolImmediate(RegisterID reg)
    839 {
    840     lshift32(Imm32(JSImmediate::ExtendedPayloadShift), reg);
    841     or32(Imm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), reg);
    842 }
    843 
    844 /* Deprecated: Please use JITStubCall instead. */
    845 
    846 // get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function.
    847 ALWAYS_INLINE void JIT::emitPutJITStubArgFromVirtualRegister(unsigned src, unsigned argumentNumber, RegisterID scratch)
    848 {
    849     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
    850     if (m_codeBlock->isConstantRegisterIndex(src)) {
    851         JSValue value = m_codeBlock->getConstant(src);
    852         poke(ImmPtr(JSValue::encode(value)), argumentStackOffset);
    853     } else {
    854         loadPtr(Address(callFrameRegister, src * sizeof(Register)), scratch);
    855         poke(scratch, argumentStackOffset);
    856     }
    857 
    858     killLastResultRegister();
    859 }
    860 
    861 #endif // USE(JSVALUE32_64)
    862 
    863 } // namespace JSC
    864 
    865 #endif // ENABLE(JIT)
    866 
    867 #endif
    868