/*

* 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_negate(Instruction* currentInstruction)

{

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

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

    emitLoad(src, regT1, regT0);

    Jump srcNotInt = branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag));

    addSlowCase(branchTest32(Zero, regT0, Imm32(0x7fffffff)));

    neg32(regT0);

    emitStoreInt32(dst, regT0, (dst == src));

    Jump end = jump();

    srcNotInt.link(this);

    addSlowCase(branch32(Above, regT1, Imm32(JSValue::LowestTag)));

    xor32(Imm32(1 << 31), regT1);

    store32(regT1, tagFor(dst));

    if (dst != src)

        store32(regT0, payloadFor(dst));

    end.link(this);

}

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

{

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

    linkSlowCase(iter); // 0x7fffffff check

    linkSlowCase(iter); // double check

    JITStubCall stubCall(this, cti_op_negate);

    stubCall.addArgument(regT1, regT0);

    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;

    JumpList notInt32Op1;

    JumpList notInt32Op2;

    // Character less.

    if (isOperandConstantImmediateChar(op1)) {

        emitLoad(op2, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

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

        return;

    }

    if (isOperandConstantImmediateChar(op2)) {

        emitLoad(op1, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

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

        return;

    }

    if (isOperandConstantImmediateInt(op1)) {

        // Int32 less.

        emitLoad(op2, regT3, regT2);

        notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

        addJump(branch32(LessThanOrEqual, regT2, Imm32(getConstantOperand(op1).asInt32())), target);

    } else if (isOperandConstantImmediateInt(op2)) {

        emitLoad(op1, regT1, regT0);

        notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        addJump(branch32(GreaterThanOrEqual, regT0, Imm32(getConstantOperand(op2).asInt32())), target);

    } else {

        emitLoad2(op1, regT1, regT0, op2, regT3, regT2);

        notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

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

    }

    if (!supportsFloatingPoint()) {

        addSlowCase(notInt32Op1);

        addSlowCase(notInt32Op2);

        return;

    }

    Jump end = jump();

    // Double less.

    emitBinaryDoubleOp(op_jnless, target, op1, op2, OperandTypes(), notInt32Op1, notInt32Op2, !isOperandConstantImmediateInt(op1), isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2));

    end.link(this);

}

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;

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

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

    } else {

        if (!supportsFloatingPoint()) {

            if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))

                linkSlowCase(iter); // int32 check

            linkSlowCase(iter); // int32 check

        } else {

            if (!isOperandConstantImmediateInt(op1)) {

                linkSlowCase(iter); // double check

                linkSlowCase(iter); // int32 check

            }

            if (isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2))

                linkSlowCase(iter); // double check

        }

    }

    JITStubCall stubCall(this, cti_op_jless);

    stubCall.addArgument(op1);

    stubCall.addArgument(op2);

    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;

    JumpList notInt32Op1;

    JumpList notInt32Op2;

    // Character less.

    if (isOperandConstantImmediateChar(op1)) {

        emitLoad(op2, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

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

        return;

    }

    if (isOperandConstantImmediateChar(op2)) {

        emitLoad(op1, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

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

        return;

    } 

    if (isOperandConstantImmediateInt(op1)) {

        emitLoad(op2, regT3, regT2);

        notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

        addJump(branch32(GreaterThan, regT2, Imm32(getConstantOperand(op1).asInt32())), target);

    } else if (isOperandConstantImmediateInt(op2)) {

        emitLoad(op1, regT1, regT0);

        notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        addJump(branch32(LessThan, regT0, Imm32(getConstantOperand(op2).asInt32())), target);

    } else {

        emitLoad2(op1, regT1, regT0, op2, regT3, regT2);

        notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

        addJump(branch32(LessThan, regT0, regT2), target);

    }

    if (!supportsFloatingPoint()) {

        addSlowCase(notInt32Op1);

        addSlowCase(notInt32Op2);

        return;

    }

    Jump end = jump();

    // Double less.

    emitBinaryDoubleOp(op_jless, target, op1, op2, OperandTypes(), notInt32Op1, notInt32Op2, !isOperandConstantImmediateInt(op1), isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2));

    end.link(this);

}

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

{

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

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

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

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

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

    } else {

        if (!supportsFloatingPoint()) {

            if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))

                linkSlowCase(iter); // int32 check

            linkSlowCase(iter); // int32 check

        } else {

            if (!isOperandConstantImmediateInt(op1)) {

                linkSlowCase(iter); // double check

                linkSlowCase(iter); // int32 check

            }

            if (isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2))

                linkSlowCase(iter); // double check

        }

    }

    JITStubCall stubCall(this, cti_op_jless);

    stubCall.addArgument(op1);

    stubCall.addArgument(op2);

    stubCall.call();

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

}

void JIT::emit_op_jlesseq(Instruction* currentInstruction, bool invert)

{

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

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

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

    JumpList notInt32Op1;

    JumpList notInt32Op2;

    // Character less.

    if (isOperandConstantImmediateChar(op1)) {

        emitLoad(op2, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

        addJump(branch32(invert ? LessThan : GreaterThanOrEqual, regT0, Imm32(asString(getConstantOperand(op1))->tryGetValue()[0])), target);

        return;

    }

    if (isOperandConstantImmediateChar(op2)) {

        emitLoad(op1, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));

        JumpList failures;

        emitLoadCharacterString(regT0, regT0, failures);

        addSlowCase(failures);

        addJump(branch32(invert ? GreaterThan : LessThanOrEqual, regT0, Imm32(asString(getConstantOperand(op2))->tryGetValue()[0])), target);

        return;

    }

    if (isOperandConstantImmediateInt(op1)) {

        emitLoad(op2, regT3, regT2);

        notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

        addJump(branch32(invert ? LessThan : GreaterThanOrEqual, regT2, Imm32(getConstantOperand(op1).asInt32())), target);

    } else if (isOperandConstantImmediateInt(op2)) {

        emitLoad(op1, regT1, regT0);

        notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        addJump(branch32(invert ? GreaterThan : LessThanOrEqual, regT0, Imm32(getConstantOperand(op2).asInt32())), target);

    } else {

        emitLoad2(op1, regT1, regT0, op2, regT3, regT2);

        notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

        addJump(branch32(invert ? GreaterThan : LessThanOrEqual, regT0, regT2), target);

    }

    if (!supportsFloatingPoint()) {

        addSlowCase(notInt32Op1);

        addSlowCase(notInt32Op2);

        return;

    }

    Jump end = jump();

    // Double less.

    emitBinaryDoubleOp(invert ? op_jnlesseq : op_jlesseq, target, op1, op2, OperandTypes(), notInt32Op1, notInt32Op2, !isOperandConstantImmediateInt(op1), isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2));

    end.link(this);

}

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

{

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

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

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

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

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

        linkSlowCase(iter);

    } else {

        if (!supportsFloatingPoint()) {

            if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))

                linkSlowCase(iter); // int32 check

            linkSlowCase(iter); // int32 check

        } else {

            if (!isOperandConstantImmediateInt(op1)) {

                linkSlowCase(iter); // double check

                linkSlowCase(iter); // int32 check

            }

            if (isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2))

                linkSlowCase(iter); // double check

        }

    }

    JITStubCall stubCall(this, cti_op_jlesseq);

    stubCall.addArgument(op1);

    stubCall.addArgument(op2);

    stubCall.call();

    emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, regT0), target);

}

void JIT::emit_op_jnlesseq(Instruction* currentInstruction)

{

    emit_op_jlesseq(currentInstruction, true);

}

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

{

    emitSlow_op_jlesseq(currentInstruction, iter, true);

}

// LeftShift (<<)

void JIT::emit_op_lshift(Instruction* currentInstruction)

{

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

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

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

    if (isOperandConstantImmediateInt(op2)) {

        emitLoad(op1, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

        lshift32(Imm32(getConstantOperand(op2).asInt32()), regT0);

        emitStoreInt32(dst, regT0, dst == op1);

        return;

    }

    emitLoad2(op1, regT1, regT0, op2, regT3, regT2);

    if (!isOperandConstantImmediateInt(op1))

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

    addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

    lshift32(regT2, regT0);

    emitStoreInt32(dst, regT0, dst == op1 || dst == op2);

}

void JIT::emitSlow_op_lshift(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(op1) && !isOperandConstantImmediateInt(op2))

        linkSlowCase(iter); // int32 check

    linkSlowCase(iter); // int32 check

    JITStubCall stubCall(this, cti_op_lshift);

    stubCall.addArgument(op1);

    stubCall.addArgument(op2);

    stubCall.call(dst);

}

// RightShift (>>) and UnsignedRightShift (>>>) helper

void JIT::emitRightShift(Instruction* currentInstruction, bool isUnsigned)

{

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

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

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

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

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

    if (isOperandConstantImmediateInt(op2)) {

        emitLoad(op1, regT1, regT0);

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

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

        if (isUnsigned) {

            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)));

        } else if (shift) { // signed right shift by zero is simply toInt conversion

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

        }

        emitStoreInt32(dst, regT0, dst == op1);

        return;

    }

    emitLoad2(op1, regT1, regT0, op2, regT3, regT2);

    if (!isOperandConstantImmediateInt(op1))

        addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));

    addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));

    if (isUnsigned) {

        urshift32(regT2, regT0);

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

    } else

        rshift32(regT2, regT0);

    emitStoreInt32(dst, regT0, dst == op1 || dst == op2);

}

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

{

    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 = regT1:regT0

        linkSlowCase(iter); // int32 check

        if (supportsFloatingPointTruncate()) {

            JumpList failures;

            failures.append(branch32(AboveOrEqual, regT1, Imm32(JSValue::LowestTag)));

            emitLoadDouble(op1, fpRegT0);

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

            if (isUnsigned) {

                if (shift)

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

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

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

            } else if (shift)

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

            emitStoreInt32(dst, regT0, false);

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

            failures.link(this);

        }

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

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

    } else {

        // op1 = regT1:regT0

        // op2 = regT3:regT2

        if (!isOperandConstantImmediateInt(op1)) {

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

            if (supportsFloatingPointTruncate()) {

                Jump notDouble = branch32(Above, regT1, Imm32(JSValue::LowestTag)); // op1 is not a double

                emitLoadDouble(op1, fpRegT0);

                Jump notInt = branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)); // op2 is not an int

                Jump cantTruncate = branchTruncateDoubleToInt32(fpRegT0, regT0);

                if (isUnsigned)

                    urshift32(regT2, regT0);

                else

                    rshift32(regT2, regT0);

                emitStoreInt32(dst, regT0, false);

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

                notDouble.link(this);

                notInt.link(this);

                cantTruncate.link(this);

            }

        }

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

        if (isUnsigned)

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

    }

    JITStubCall stubCall(this, isUnsigned ? cti_op_urshift : cti_op_rshift);

    stubCall.addArgument(op1);

    stubCall.addArgument(op2);

    stubCall.call(dst);

}

// RightShift (>>)

void JIT::emit_op_rshift(Instruction* currentInstruction)

{

    emitRightShift(currentInstruction, false);

}

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

{

    emitRightShiftSlowCase(currentInstruction, iter, false);

}

// UnsignedRightShift (>>>)

void JIT::emit_op_urshift(Instruction* currentInstruction)

{

    emitRightShift(currentInstruction, true);

}

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

{

    emitRightShiftSlowCase(currentInstruction, iter, true);

}

// BitAnd (&)

void JIT::emit_op_bitand(Instruction* currentInstruction)