/*

 * Copyright (C) 2008 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#ifndef JITInlineMethods_h

#define JITInlineMethods_h

#include <wtf/Platform.h>

#if ENABLE(JIT)

namespace JSC {

/* Deprecated: Please use JITStubCall instead. */

// puts an arg onto the stack, as an arg to a context threaded function.

ALWAYS_INLINE void JIT::emitPutJITStubArg(RegisterID src, unsigned argumentNumber)

{

    unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + 1;

    poke(src, argumentStackOffset);

}

/* Deprecated: Please use JITStubCall instead. */

ALWAYS_INLINE void JIT::emitPutJITStubArgConstant(unsigned value, unsigned argumentNumber)

{

    unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + 1;

    poke(Imm32(value), argumentStackOffset);

}

/* Deprecated: Please use JITStubCall instead. */

ALWAYS_INLINE void JIT::emitPutJITStubArgConstant(void* value, unsigned argumentNumber)

{

    unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + 1;

    poke(ImmPtr(value), argumentStackOffset);

}

/* Deprecated: Please use JITStubCall instead. */

ALWAYS_INLINE void JIT::emitGetJITStubArg(unsigned argumentNumber, RegisterID dst)

{

    unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + 1;

    peek(dst, argumentStackOffset);

}

ALWAYS_INLINE bool JIT::isOperandConstantImmediateDouble(unsigned src)

{

    return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isDouble();

}

ALWAYS_INLINE JSValue JIT::getConstantOperand(unsigned src)

{

    ASSERT(m_codeBlock->isConstantRegisterIndex(src));

    return m_codeBlock->getConstant(src);

}

ALWAYS_INLINE void JIT::emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)

{

    storePtr(from, Address(callFrameRegister, entry * sizeof(Register)));

}

ALWAYS_INLINE void JIT::emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)

{

    storePtr(ImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));

}

ALWAYS_INLINE void JIT::emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)

{

    loadPtr(Address(from, entry * sizeof(Register)), to);

#if !USE(JSVALUE32_64)

    killLastResultRegister();

#endif

}

ALWAYS_INLINE void JIT::emitGetFromCallFrameHeader32(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)

{

    load32(Address(from, entry * sizeof(Register)), to);

#if !USE(JSVALUE32_64)

    killLastResultRegister();

#endif

}

ALWAYS_INLINE JIT::Call JIT::emitNakedCall(CodePtr function)

{

    ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.

    Call nakedCall = nearCall();

    m_calls.append(CallRecord(nakedCall, m_bytecodeIndex, function.executableAddress()));

    return nakedCall;

}

#if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL

ALWAYS_INLINE void JIT::beginUninterruptedSequence(int insnSpace, int constSpace)

{

#if PLATFORM(ARM_TRADITIONAL)

#ifndef NDEBUG

    // Ensure the label after the sequence can also fit

    insnSpace += sizeof(ARMWord);

    constSpace += sizeof(uint64_t);

#endif

    ensureSpace(insnSpace, constSpace);

#endif

#if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL

#ifndef NDEBUG

    m_uninterruptedInstructionSequenceBegin = label();

    m_uninterruptedConstantSequenceBegin = sizeOfConstantPool();

#endif

#endif

}

ALWAYS_INLINE void JIT::endUninterruptedSequence(int insnSpace, int constSpace)

{

#if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL

    ASSERT(differenceBetween(m_uninterruptedInstructionSequenceBegin, label()) == insnSpace);

    ASSERT(sizeOfConstantPool() - m_uninterruptedConstantSequenceBegin == constSpace);

#endif

}

#endif

ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)

{

    move(linkRegister, reg);

}

ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)

{

    move(reg, linkRegister);

}

ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)

{

    loadPtr(address, linkRegister);

}

ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)

{

    pop(reg);

}

ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)

{

    push(reg);

}

ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)

{

    push(address);

}

#endif

#if USE(JIT_STUB_ARGUMENT_VA_LIST)

ALWAYS_INLINE void JIT::restoreArgumentReference()

{

    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));

}

ALWAYS_INLINE void JIT::restoreArgumentReferenceForTrampoline() {}

#else

ALWAYS_INLINE void JIT::restoreArgumentReference()

{

    move(stackPointerRegister, firstArgumentRegister);

    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));

}

ALWAYS_INLINE void JIT::restoreArgumentReferenceForTrampoline()

{

#if PLATFORM(X86)

    // Within a trampoline the return address will be on the stack at this point.

    addPtr(Imm32(sizeof(void*)), stackPointerRegister, firstArgumentRegister);

    move(stackPointerRegister, firstArgumentRegister);

#endif

    // In the trampoline on x86-64, the first argument register is not overwritten.

}

#endif

ALWAYS_INLINE JIT::Jump JIT::checkStructure(RegisterID reg, Structure* structure)

{

    return branchPtr(NotEqual, Address(reg, OBJECT_OFFSETOF(JSCell, m_structure)), ImmPtr(structure));

}

ALWAYS_INLINE void JIT::linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator& iter, int vReg)

{

    if (!m_codeBlock->isKnownNotImmediate(vReg))

        linkSlowCase(iter);

}

ALWAYS_INLINE void JIT::addSlowCase(Jump jump)

{

    ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.

    m_slowCases.append(SlowCaseEntry(jump, m_bytecodeIndex));

}

ALWAYS_INLINE void JIT::addSlowCase(JumpList jumpList)

{

    ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.

    const JumpList::JumpVector& jumpVector = jumpList.jumps();

    size_t size = jumpVector.size();

    for (size_t i = 0; i < size; ++i)

        m_slowCases.append(SlowCaseEntry(jumpVector[i], m_bytecodeIndex));

}

ALWAYS_INLINE void JIT::addJump(Jump jump, int relativeOffset)

{

    ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.

    m_jmpTable.append(JumpTable(jump, m_bytecodeIndex + relativeOffset));

}

ALWAYS_INLINE void JIT::emitJumpSlowToHot(Jump jump, int relativeOffset)

{

    ASSERT(m_bytecodeIndex != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeIndex is set.

    jump.linkTo(m_labels[m_bytecodeIndex + relativeOffset], this);

}

#if ENABLE(SAMPLING_FLAGS)

ALWAYS_INLINE void JIT::setSamplingFlag(int32_t flag)

{

    ASSERT(flag >= 1);

    ASSERT(flag <= 32);

    or32(Imm32(1u << (flag - 1)), AbsoluteAddress(&SamplingFlags::s_flags));

}

ALWAYS_INLINE void JIT::clearSamplingFlag(int32_t flag)

{

    ASSERT(flag >= 1);

    ASSERT(flag <= 32);

    and32(Imm32(~(1u << (flag - 1))), AbsoluteAddress(&SamplingFlags::s_flags));

}

#endif

#if ENABLE(SAMPLING_COUNTERS)

ALWAYS_INLINE void JIT::emitCount(AbstractSamplingCounter& counter, uint32_t count)

{

#if PLATFORM(X86_64) // Or any other 64-bit plattform.

    addPtr(Imm32(count), AbsoluteAddress(&counter.m_counter));

#elif PLATFORM(X86) // Or any other little-endian 32-bit plattform.

    intptr_t hiWord = reinterpret_cast<intptr_t>(&counter.m_counter) + sizeof(int32_t);

    add32(Imm32(count), AbsoluteAddress(&counter.m_counter));

    addWithCarry32(Imm32(0), AbsoluteAddress(reinterpret_cast<void*>(hiWord)));

#else

#error "SAMPLING_FLAGS not implemented on this platform."

#endif

}

#endif

#if ENABLE(OPCODE_SAMPLING)

#if PLATFORM(X86_64)

ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)

{

    move(ImmPtr(m_interpreter->sampler()->sampleSlot()), X86Registers::ecx);

    storePtr(ImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), X86Registers::ecx);

}

#else

ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)

{

    storePtr(ImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), m_interpreter->sampler()->sampleSlot());

}

#endif

#endif

#if ENABLE(CODEBLOCK_SAMPLING)

#if PLATFORM(X86_64)

ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)

{

    move(ImmPtr(m_interpreter->sampler()->codeBlockSlot()), X86Registers::ecx);

    storePtr(ImmPtr(codeBlock), X86Registers::ecx);

}

#else

ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)

{

    storePtr(ImmPtr(codeBlock), m_interpreter->sampler()->codeBlockSlot());

}

#endif

#endif

inline JIT::Address JIT::addressFor(unsigned index, RegisterID base)

{

    return Address(base, (index * sizeof(Register)));

}

#if USE(JSVALUE32_64)

inline JIT::Address JIT::tagFor(unsigned index, RegisterID base)

{

    return Address(base, (index * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.tag));

}

inline JIT::Address JIT::payloadFor(unsigned index, RegisterID base)

{

    return Address(base, (index * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.payload));

}

inline void JIT::emitLoadTag(unsigned index, RegisterID tag)

{

    RegisterID mappedTag;

    if (getMappedTag(index, mappedTag)) {

        move(mappedTag, tag);

        unmap(tag);

        return;

    }

    if (m_codeBlock->isConstantRegisterIndex(index)) {

        move(Imm32(getConstantOperand(index).tag()), tag);

        unmap(tag);

        return;

    }

    load32(tagFor(index), tag);

    unmap(tag);

}

inline void JIT::emitLoadPayload(unsigned index, RegisterID payload)

{

    RegisterID mappedPayload;

    if (getMappedPayload(index, mappedPayload)) {

        move(mappedPayload, payload);

        unmap(payload);

        return;

    }

    if (m_codeBlock->isConstantRegisterIndex(index)) {

        move(Imm32(getConstantOperand(index).payload()), payload);

        unmap(payload);

        return;

    }

    load32(payloadFor(index), payload);

    unmap(payload);

}

inline void JIT::emitLoad(const JSValue& v, RegisterID tag, RegisterID payload)

{

    move(Imm32(v.payload()), payload);

    move(Imm32(v.tag()), tag);

}

inline void JIT::emitLoad(unsigned index, RegisterID tag, RegisterID payload, RegisterID base)

{

    ASSERT(tag != payload);

    if (base == callFrameRegister) {

        ASSERT(payload != base);

        emitLoadPayload(index, payload);

        emitLoadTag(index, tag);

        return;

    }

    if (payload == base) { // avoid stomping base

        load32(tagFor(index, base), tag);

        load32(payloadFor(index, base), payload);

        return;

    }

    load32(payloadFor(index, base), payload);

    load32(tagFor(index, base), tag);

}

inline void JIT::emitLoad2(unsigned index1, RegisterID tag1, RegisterID payload1, unsigned index2, RegisterID tag2, RegisterID payload2)

{

    if (isMapped(index1)) {

        emitLoad(index1, tag1, payload1);

        emitLoad(index2, tag2, payload2);

        return;

    }

    emitLoad(index2, tag2, payload2);

    emitLoad(index1, tag1, payload1);

}

inline void JIT::emitLoadDouble(unsigned index, FPRegisterID value)

{

    if (m_codeBlock->isConstantRegisterIndex(index)) {

        Register& inConstantPool = m_codeBlock->constantRegister(index);

        loadDouble(&inConstantPool, value);

    } else

        loadDouble(addressFor(index), value);

}

inline void JIT::emitLoadInt32ToDouble(unsigned index, FPRegisterID value)

{

    if (m_codeBlock->isConstantRegisterIndex(index)) {

        Register& inConstantPool = m_codeBlock->constantRegister(index);

        char* bytePointer = reinterpret_cast<char*>(&inConstantPool);

        convertInt32ToDouble(AbsoluteAddress(bytePointer + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), value);

    } else

        convertInt32ToDouble(payloadFor(index), value);

}

inline void JIT::emitStore(unsigned index, RegisterID tag, RegisterID payload, RegisterID base)

{

    store32(payload, payloadFor(index, base));

    store32(tag, tagFor(index, base));

}

inline void JIT::emitStoreInt32(unsigned index, RegisterID payload, bool indexIsInt32)

{

    store32(payload, payloadFor(index, callFrameRegister));

    if (!indexIsInt32)

        store32(Imm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));

}

inline void JIT::emitStoreInt32(unsigned index, Imm32 payload, bool indexIsInt32)

{

    store32(payload, payloadFor(index, callFrameRegister));

    if (!indexIsInt32)

        store32(Imm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));

}

inline void JIT::emitStoreCell(unsigned index, RegisterID payload, bool indexIsCell)

{

    store32(payload, payloadFor(index, callFrameRegister));

    if (!indexIsCell)

        store32(Imm32(JSValue::CellTag), tagFor(index, callFrameRegister));

}

inline void JIT::emitStoreBool(unsigned index, RegisterID tag, bool indexIsBool)

{

    if (!indexIsBool)

        store32(Imm32(0), payloadFor(index, callFrameRegister));

    store32(tag, tagFor(index, callFrameRegister));

}

inline void JIT::emitStoreDouble(unsigned index, FPRegisterID value)

{

    storeDouble(value, addressFor(index));

}

inline void JIT::emitStore(unsigned index, const JSValue constant, RegisterID base)

{

    store32(Imm32(constant.payload()), payloadFor(index, base));

    store32(Imm32(constant.tag()), tagFor(index, base));

}

ALWAYS_INLINE void JIT::emitInitRegister(unsigned dst)

{

    emitStore(dst, jsUndefined());

}

inline bool JIT::isLabeled(unsigned bytecodeIndex)

{

    for (size_t numberOfJumpTargets = m_codeBlock->numberOfJumpTargets(); m_jumpTargetIndex != numberOfJumpTargets; ++m_jumpTargetIndex) {

        unsigned jumpTarget = m_codeBlock->jumpTarget(m_jumpTargetIndex);

        if (jumpTarget == bytecodeIndex)

            return true;

        if (jumpTarget > bytecodeIndex)

            return false;

    }

    return false;

}

inline void JIT::map(unsigned bytecodeIndex, unsigned virtualRegisterIndex, RegisterID tag, RegisterID payload)

{

    if (isLabeled(bytecodeIndex))

        return;

    m_mappedBytecodeIndex = bytecodeIndex;

    m_mappedVirtualRegisterIndex = virtualRegisterIndex;

    m_mappedTag = tag;

    m_mappedPayload = payload;

}

inline void JIT::unmap(RegisterID registerID)

{

    if (m_mappedTag == registerID)

        m_mappedTag = (RegisterID)-1;

    else if (m_mappedPayload == registerID)

        m_mappedPayload = (RegisterID)-1;

}

inline void JIT::unmap()

{

    m_mappedBytecodeIndex = (unsigned)-1;

    m_mappedVirtualRegisterIndex = (unsigned)-1;

    m_mappedTag = (RegisterID)-1;

    m_mappedPayload = (RegisterID)-1;

}

inline bool JIT::isMapped(unsigned virtualRegisterIndex)

{

    if (m_mappedBytecodeIndex != m_bytecodeIndex)

        return false;

    if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)

        return false;

    return true;

}

inline bool JIT::getMappedPayload(unsigned virtualRegisterIndex, RegisterID& payload)

{

    if (m_mappedBytecodeIndex != m_bytecodeIndex)

        return false;

    if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)

        return false;

    if (m_mappedPayload == (RegisterID)-1)

        return false;

    payload = m_mappedPayload;