/*

 * 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.

 */

#include "config.h"

#if ENABLE(JIT)

#if !USE(JSVALUE32_64)

#include "JIT.h"

#include "CodeBlock.h"

#include "JITInlineMethods.h"

#include "JITStubCall.h"

#include "JITStubs.h"

#include "JSArray.h"

#include "JSFunction.h"

#include "Interpreter.h"

#include "ResultType.h"

#include "SamplingTool.h"

#ifndef NDEBUG

#include <stdio.h>

#endif

using namespace std;

namespace JSC {

void JIT::emit_op_lshift(Instruction* currentInstruction)

{

    unsigned result = currentInstruction[1].u.operand;

    unsigned op1 = currentInstruction[2].u.operand;

    unsigned op2 = currentInstruction[3].u.operand;

    emitGetVirtualRegisters(op1, regT0, op2, regT2);

    // FIXME: would we be better using 'emitJumpSlowCaseIfNotImmediateIntegers'? - we *probably* ought to be consistent.

    emitJumpSlowCaseIfNotImmediateInteger(regT0);

    emitJumpSlowCaseIfNotImmediateInteger(regT2);

    emitFastArithImmToInt(regT0);

    emitFastArithImmToInt(regT2);

    lshift32(regT2, regT0);

#if USE(JSVALUE32)

    addSlowCase(branchAdd32(Overflow, regT0, regT0));

    signExtend32ToPtr(regT0, regT0);

#endif

    emitFastArithReTagImmediate(regT0, regT0);

    emitPutVirtualRegister(result);

}

void JIT::emitSlow_op_lshift(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)

{

    unsigned result = currentInstruction[1].u.operand;

    unsigned op1 = currentInstruction[2].u.operand;

    unsigned op2 = currentInstruction[3].u.operand;

#if USE(JSVALUE64)

    UNUSED_PARAM(op1);

    UNUSED_PARAM(op2);

    linkSlowCase(iter);

    linkSlowCase(iter);

#else

    // If we are limited to 32-bit immediates there is a third slow case, which required the operands to have been reloaded.

    Jump notImm1 = getSlowCase(iter);

    Jump notImm2 = getSlowCase(iter);

    linkSlowCase(iter);

    emitGetVirtualRegisters(op1, regT0, op2, regT2);

    notImm1.link(this);

    notImm2.link(this);

#endif

    JITStubCall stubCall(this, cti_op_lshift);

    stubCall.addArgument(regT0);

    stubCall.addArgument(regT2);

    stubCall.call(result);

}

void JIT::emit_op_rshift(Instruction* currentInstruction)

{

    unsigned result = currentInstruction[1].u.operand;

    unsigned op1 = currentInstruction[2].u.operand;

    unsigned op2 = currentInstruction[3].u.operand;

    if (isOperandConstantImmediateInt(op2)) {

        // isOperandConstantImmediateInt(op2) => 1 SlowCase

        emitGetVirtualRegister(op1, regT0);

        emitJumpSlowCaseIfNotImmediateInteger(regT0);

        // Mask with 0x1f as per ecma-262 11.7.2 step 7.

        rshift32(Imm32(getConstantOperandImmediateInt(op2) & 0x1f), regT0);

    } else {

        emitGetVirtualRegisters(op1, regT0, op2, regT2);

        if (supportsFloatingPointTruncate()) {

            Jump lhsIsInt = emitJumpIfImmediateInteger(regT0);

#if USE(JSVALUE64)

            // supportsFloatingPoint() && USE(JSVALUE64) => 3 SlowCases

            addSlowCase(emitJumpIfNotImmediateNumber(regT0));

            addPtr(tagTypeNumberRegister, regT0);

            movePtrToDouble(regT0, fpRegT0);

            addSlowCase(branchTruncateDoubleToInt32(fpRegT0, regT0));

#else

            // supportsFloatingPoint() && !USE(JSVALUE64) => 5 SlowCases (of which 1 IfNotJSCell)

            emitJumpSlowCaseIfNotJSCell(regT0, op1);

            addSlowCase(checkStructure(regT0, m_globalData->numberStructure.get()));

            loadDouble(Address(regT0, OBJECT_OFFSETOF(JSNumberCell, m_value)), fpRegT0);

            addSlowCase(branchTruncateDoubleToInt32(fpRegT0, regT0));

            addSlowCase(branchAdd32(Overflow, regT0, regT0));

#endif

            lhsIsInt.link(this);

            emitJumpSlowCaseIfNotImmediateInteger(regT2);

        } else {

            // !supportsFloatingPoint() => 2 SlowCases

            emitJumpSlowCaseIfNotImmediateInteger(regT0);

            emitJumpSlowCaseIfNotImmediateInteger(regT2);

        }

        emitFastArithImmToInt(regT2);

        rshift32(regT2, regT0);

#if USE(JSVALUE32)

        signExtend32ToPtr(regT0, regT0);

#endif

    }

#if USE(JSVALUE64)

    emitFastArithIntToImmNoCheck(regT0, regT0);

#else

    orPtr(Imm32(JSImmediate::TagTypeNumber), regT0);

#endif

    emitPutVirtualRegister(result);

}

void JIT::emitSlow_op_rshift(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)

{

    unsigned result = currentInstruction[1].u.operand;

    unsigned op1 = currentInstruction[2].u.operand;

    unsigned op2 = currentInstruction[3].u.operand;

    JITStubCall stubCall(this, cti_op_rshift);

    if (isOperandConstantImmediateInt(op2)) {

        linkSlowCase(iter);

        stubCall.addArgument(regT0);

        stubCall.addArgument(op2, regT2);

    } else {

        if (supportsFloatingPointTruncate()) {

#if USE(JSVALUE64)

            linkSlowCase(iter);

            linkSlowCase(iter);

            linkSlowCase(iter);

#else

            linkSlowCaseIfNotJSCell(iter, op1);

            linkSlowCase(iter);

            linkSlowCase(iter);

            linkSlowCase(iter);

            linkSlowCase(iter);

#endif

            // We're reloading op1 to regT0 as we can no longer guarantee that

            // we have not munged the operand.  It may have already been shifted

            // correctly, but it still will not have been tagged.

            stubCall.addArgument(op1, regT0);

            stubCall.addArgument(regT2);

        } else {

            linkSlowCase(iter);

            linkSlowCase(iter);

            stubCall.addArgument(regT0);

            stubCall.addArgument(regT2);

        }

    }

    stubCall.call(result);

}

void JIT::emit_op_urshift(Instruction* currentInstruction)

{

    unsigned dst = currentInstruction[1].u.operand;

    unsigned op1 = currentInstruction[2].u.operand;

    unsigned op2 = currentInstruction[3].u.operand;

    // Slow case of urshift makes assumptions about what registers hold the

    // shift arguments, so any changes must be updated there as well.

    if (isOperandConstantImmediateInt(op2)) {

        emitGetVirtualRegister(op1, regT0);

        emitJumpSlowCaseIfNotImmediateInteger(regT0);

        emitFastArithImmToInt(regT0);

        int shift = getConstantOperand(op2).asInt32();

        if (shift)

            urshift32(Imm32(shift & 0x1f), regT0);

        // unsigned shift < 0 or shift = k*2^32 may result in (essentially)

        // a toUint conversion, which can result in a value we can represent

        // as an immediate int.

        if (shift < 0 || !(shift & 31))

            addSlowCase(branch32(LessThan, regT0, Imm32(0)));

#if USE(JSVALUE32)

        addSlowCase(branchAdd32(Overflow, regT0, regT0));

        signExtend32ToPtr(regT0, regT0);

#endif

        emitFastArithReTagImmediate(regT0, regT0);

        emitPutVirtualRegister(dst, regT0);

        return;

    }

    emitGetVirtualRegisters(op1, regT0, op2, regT1);

    if (!isOperandConstantImmediateInt(op1))

        emitJumpSlowCaseIfNotImmediateInteger(regT0);

    emitJumpSlowCaseIfNotImmediateInteger(regT1);

    emitFastArithImmToInt(regT0);

    emitFastArithImmToInt(regT1);

    urshift32(regT1, regT0);

    addSlowCase(branch32(LessThan, regT0, Imm32(0)));

#if USE(JSVALUE32)

    addSlowCase(branchAdd32(Overflow, regT0, regT0));

    signExtend32ToPtr(regT0, regT0);

#endif

    emitFastArithReTagImmediate(regT0, regT0);

    emitPutVirtualRegister(dst, regT0);

}

void JIT::emitSlow_op_urshift(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)

{

    unsigned dst = currentInstruction[1].u.operand;

    unsigned op1 = currentInstruction[2].u.operand;

    unsigned op2 = currentInstruction[3].u.operand;

    if (isOperandConstantImmediateInt(op2)) {

        int shift = getConstantOperand(op2).asInt32();

        // op1 = regT0

        linkSlowCase(iter); // int32 check

#if USE(JSVALUE64)

        if (supportsFloatingPointTruncate()) {

            JumpList failures;

            failures.append(emitJumpIfNotImmediateNumber(regT0)); // op1 is not a double

            addPtr(tagTypeNumberRegister, regT0);

            movePtrToDouble(regT0, fpRegT0);

            failures.append(branchTruncateDoubleToInt32(fpRegT0, regT0));

            if (shift)

                urshift32(Imm32(shift & 0x1f), regT0);

            if (shift < 0 || !(shift & 31))

                failures.append(branch32(LessThan, regT0, Imm32(0)));

            emitFastArithReTagImmediate(regT0, regT0);

            emitPutVirtualRegister(dst, regT0);

            emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_rshift));

            failures.link(this);

        }

#endif // JSVALUE64

        if (shift < 0 || !(shift & 31))

            linkSlowCase(iter); // failed to box in hot path

#if USE(JSVALUE32)

        linkSlowCase(iter); // Couldn't box result

#endif

    } else {

        // op1 = regT0

        // op2 = regT1

        if (!isOperandConstantImmediateInt(op1)) {

            linkSlowCase(iter); // int32 check -- op1 is not an int

#if USE(JSVALUE64)

            if (supportsFloatingPointTruncate()) {

                JumpList failures;

                failures.append(emitJumpIfNotImmediateNumber(regT0)); // op1 is not a double

                addPtr(tagTypeNumberRegister, regT0);

                movePtrToDouble(regT0, fpRegT0);

                failures.append(branchTruncateDoubleToInt32(fpRegT0, regT0));

                failures.append(emitJumpIfNotImmediateInteger(regT1)); // op2 is not an int

                emitFastArithImmToInt(regT1);

                urshift32(regT1, regT0);

                failures.append(branch32(LessThan, regT0, Imm32(0)));

                emitFastArithReTagImmediate(regT0, regT0);

                emitPutVirtualRegister(dst, regT0);

                emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_rshift));

                failures.link(this);

            }

#endif

        }

        linkSlowCase(iter); // int32 check - op2 is not an int

        linkSlowCase(iter); // Can't represent unsigned result as an immediate

#if USE(JSVALUE32)

        linkSlowCase(iter); // Couldn't box result

#endif

    }

    JITStubCall stubCall(this, cti_op_urshift);

    stubCall.addArgument(op1, regT0);

    stubCall.addArgument(op2, regT1);

    stubCall.call(dst);

}

void JIT::emit_op_jnless(Instruction* currentInstruction)

{

    unsigned op1 = currentInstruction[1].u.operand;

    unsigned op2 = currentInstruction[2].u.operand;

    unsigned target = currentInstruction[3].u.operand;

    // We generate inline code for the following cases in the fast path:

    // - int immediate to constant int immediate

    // - constant int immediate to int immediate

    // - int immediate to int immediate

    if (isOperandConstantImmediateChar(op1)) {

        emitGetVirtualRegister(op2, regT0);

        addSlowCase(emitJumpIfNotJSCell(regT0));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

        addJump(branch32(LessThanOrEqual, regT0, Imm32(asString(getConstantOperand(op1))->tryGetValue()[0])), target);

        return;

    }

    if (isOperandConstantImmediateChar(op2)) {

        emitGetVirtualRegister(op1, regT0);

        addSlowCase(emitJumpIfNotJSCell(regT0));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

        addJump(branch32(GreaterThanOrEqual, regT0, Imm32(asString(getConstantOperand(op2))->tryGetValue()[0])), target);

        return;

    }

    if (isOperandConstantImmediateInt(op2)) {

        emitGetVirtualRegister(op1, regT0);

        emitJumpSlowCaseIfNotImmediateInteger(regT0);

#if USE(JSVALUE64)

        int32_t op2imm = getConstantOperandImmediateInt(op2);

#else

        int32_t op2imm = static_cast<int32_t>(JSImmediate::rawValue(getConstantOperand(op2)));

#endif

        addJump(branch32(GreaterThanOrEqual, regT0, Imm32(op2imm)), target);

    } else if (isOperandConstantImmediateInt(op1)) {

        emitGetVirtualRegister(op2, regT1);

        emitJumpSlowCaseIfNotImmediateInteger(regT1);

#if USE(JSVALUE64)

        int32_t op1imm = getConstantOperandImmediateInt(op1);

#else

        int32_t op1imm = static_cast<int32_t>(JSImmediate::rawValue(getConstantOperand(op1)));

#endif

        addJump(branch32(LessThanOrEqual, regT1, Imm32(op1imm)), target);

    } else {

        emitGetVirtualRegisters(op1, regT0, op2, regT1);

        emitJumpSlowCaseIfNotImmediateInteger(regT0);

        emitJumpSlowCaseIfNotImmediateInteger(regT1);

        addJump(branch32(GreaterThanOrEqual, regT0, regT1), target);

    }

}

void JIT::emitSlow_op_jnless(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)

{

    unsigned op1 = currentInstruction[1].u.operand;

    unsigned op2 = currentInstruction[2].u.operand;

    unsigned target = currentInstruction[3].u.operand;

    // We generate inline code for the following cases in the slow path:

    // - floating-point number to constant int immediate

    // - constant int immediate to floating-point number

    // - floating-point number to floating-point number.

    if (isOperandConstantImmediateChar(op1) || isOperandConstantImmediateChar(op2)) {

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

        JITStubCall stubCall(this, cti_op_jless);

        stubCall.addArgument(op1, regT0);

        stubCall.addArgument(op2, regT1);

        stubCall.call();

        emitJumpSlowToHot(branchTest32(Zero, regT0), target);

        return;

    }

    if (isOperandConstantImmediateInt(op2)) {

        linkSlowCase(iter);

        if (supportsFloatingPoint()) {

#if USE(JSVALUE64)

            Jump fail1 = emitJumpIfNotImmediateNumber(regT0);

            addPtr(tagTypeNumberRegister, regT0);

            movePtrToDouble(regT0, fpRegT0);

#else

            Jump fail1;

            if (!m_codeBlock->isKnownNotImmediate(op1))

                fail1 = emitJumpIfNotJSCell(regT0);

            Jump fail2 = checkStructure(regT0, m_globalData->numberStructure.get());

            loadDouble(Address(regT0, OBJECT_OFFSETOF(JSNumberCell, m_value)), fpRegT0);

#endif

            int32_t op2imm = getConstantOperand(op2).asInt32();;

            move(Imm32(op2imm), regT1);

            convertInt32ToDouble(regT1, fpRegT1);

            emitJumpSlowToHot(branchDouble(DoubleLessThanOrEqualOrUnordered, fpRegT1, fpRegT0), target);

            emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_jnless));

#if USE(JSVALUE64)

            fail1.link(this);

#else

            if (!m_codeBlock->isKnownNotImmediate(op1))

                fail1.link(this);

            fail2.link(this);

#endif

        }

        JITStubCall stubCall(this, cti_op_jless);

        stubCall.addArgument(regT0);

        stubCall.addArgument(op2, regT2);

        stubCall.call();

        emitJumpSlowToHot(branchTest32(Zero, regT0), target);

    } else if (isOperandConstantImmediateInt(op1)) {

        linkSlowCase(iter);

        if (supportsFloatingPoint()) {

#if USE(JSVALUE64)

            Jump fail1 = emitJumpIfNotImmediateNumber(regT1);

            addPtr(tagTypeNumberRegister, regT1);

            movePtrToDouble(regT1, fpRegT1);

#else

            Jump fail1;

            if (!m_codeBlock->isKnownNotImmediate(op2))

                fail1 = emitJumpIfNotJSCell(regT1);

            Jump fail2 = checkStructure(regT1, m_globalData->numberStructure.get());

            loadDouble(Address(regT1, OBJECT_OFFSETOF(JSNumberCell, m_value)), fpRegT1);

#endif

            int32_t op1imm = getConstantOperand(op1).asInt32();;

            move(Imm32(op1imm), regT0);

            convertInt32ToDouble(regT0, fpRegT0);

            emitJumpSlowToHot(branchDouble(DoubleLessThanOrEqualOrUnordered, fpRegT1, fpRegT0), target);

            emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_jnless));

#if USE(JSVALUE64)

            fail1.link(this);

#else

            if (!m_codeBlock->isKnownNotImmediate(op2))

                fail1.link(this);

            fail2.link(this);

#endif

        }

        JITStubCall stubCall(this, cti_op_jless);

        stubCall.addArgument(op1, regT2);

        stubCall.addArgument(regT1);

        stubCall.call();

        emitJumpSlowToHot(branchTest32(Zero, regT0), target);

    } else {

        linkSlowCase(iter);

        if (supportsFloatingPoint()) {

#if USE(JSVALUE64)

            Jump fail1 = emitJumpIfNotImmediateNumber(regT0);

            Jump fail2 = emitJumpIfNotImmediateNumber(regT1);

            Jump fail3 = emitJumpIfImmediateInteger(regT1);

            addPtr(tagTypeNumberRegister, regT0);

            addPtr(tagTypeNumberRegister, regT1);

            movePtrToDouble(regT0, fpRegT0);

            movePtrToDouble(regT1, fpRegT1);

#else

            Jump fail1;

            if (!m_codeBlock->isKnownNotImmediate(op1))

                fail1 = emitJumpIfNotJSCell(regT0);

            Jump fail2;

            if (!m_codeBlock->isKnownNotImmediate(op2))

                fail2 = emitJumpIfNotJSCell(regT1);

            Jump fail3 = checkStructure(regT0, m_globalData->numberStructure.get());

            Jump fail4 = checkStructure(regT1, m_globalData->numberStructure.get());

            loadDouble(Address(regT0, OBJECT_OFFSETOF(JSNumberCell, m_value)), fpRegT0);

            loadDouble(Address(regT1, OBJECT_OFFSETOF(JSNumberCell, m_value)), fpRegT1);

#endif

            emitJumpSlowToHot(branchDouble(DoubleLessThanOrEqualOrUnordered, fpRegT1, fpRegT0), target);

            emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_jnless));

#if USE(JSVALUE64)

            fail1.link(this);

            fail2.link(this);

            fail3.link(this);

#else

            if (!m_codeBlock->isKnownNotImmediate(op1))

                fail1.link(this);

            if (!m_codeBlock->isKnownNotImmediate(op2))

                fail2.link(this);

            fail3.link(this);

            fail4.link(this);

#endif

        }

        linkSlowCase(iter);

        JITStubCall stubCall(this, cti_op_jless);

        stubCall.addArgument(regT0);

        stubCall.addArgument(regT1);

        stubCall.call();

        emitJumpSlowToHot(branchTest32(Zero, regT0), target);

    }

}

void JIT::emit_op_jless(Instruction* currentInstruction)

{

    unsigned op1 = currentInstruction[1].u.operand;

    unsigned op2 = currentInstruction[2].u.operand;

    unsigned target = currentInstruction[3].u.operand;

    // We generate inline code for the following cases in the fast path:

    // - int immediate to constant int immediate

    // - constant int immediate to int immediate

    // - int immediate to int immediate

    if (isOperandConstantImmediateChar(op1)) {

        emitGetVirtualRegister(op2, regT0);