/*

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

 * Copyright (C) 2010 MIPS Technologies, 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 MIPS TECHNOLOGIES, 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 MIPS TECHNOLOGIES, 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 MacroAssemblerMIPS_h

#define MacroAssemblerMIPS_h

#if ENABLE(ASSEMBLER) && CPU(MIPS)

#include "AbstractMacroAssembler.h"

#include "MIPSAssembler.h"

namespace JSC {

class MacroAssemblerMIPS : public AbstractMacroAssembler<MIPSAssembler> {

public:

    typedef MIPSRegisters::FPRegisterID FPRegisterID;

    MacroAssemblerMIPS()

        : m_fixedWidth(false)

    {

    }

    static const Scale ScalePtr = TimesFour;

    // For storing immediate number

    static const RegisterID immTempRegister = MIPSRegisters::t0;

    // For storing data loaded from the memory

    static const RegisterID dataTempRegister = MIPSRegisters::t1;

    // For storing address base

    static const RegisterID addrTempRegister = MIPSRegisters::t2;

    // For storing compare result

    static const RegisterID cmpTempRegister = MIPSRegisters::t3;

    // FP temp register

    static const FPRegisterID fpTempRegister = MIPSRegisters::f16;

    enum Condition {

        Equal,

        NotEqual,

        Above,

        AboveOrEqual,

        Below,

        BelowOrEqual,

        GreaterThan,

        GreaterThanOrEqual,

        LessThan,

        LessThanOrEqual,

        Overflow,

        Signed,

        Zero,

        NonZero

    };

    enum DoubleCondition {

        DoubleEqual,

        DoubleNotEqual,

        DoubleGreaterThan,

        DoubleGreaterThanOrEqual,

        DoubleLessThan,

        DoubleLessThanOrEqual,

        DoubleEqualOrUnordered,

        DoubleNotEqualOrUnordered,

        DoubleGreaterThanOrUnordered,

        DoubleGreaterThanOrEqualOrUnordered,

        DoubleLessThanOrUnordered,

        DoubleLessThanOrEqualOrUnordered

    };

    static const RegisterID stackPointerRegister = MIPSRegisters::sp;

    static const RegisterID returnAddressRegister = MIPSRegisters::ra;

    // Integer arithmetic operations:

    //

    // Operations are typically two operand - operation(source, srcDst)

    // For many operations the source may be an Imm32, the srcDst operand

    // may often be a memory location (explictly described using an Address

    // object).

    void add32(RegisterID src, RegisterID dest)

    {

        m_assembler.addu(dest, dest, src);

    }

    void add32(Imm32 imm, RegisterID dest)

    {

        add32(imm, dest, dest);

    }

    void add32(Imm32 imm, RegisterID src, RegisterID dest)

    {

        if (!imm.m_isPointer && imm.m_value >= -32768 && imm.m_value <= 32767

            && !m_fixedWidth) {

            /*

              addiu     dest, src, imm

            */

            m_assembler.addiu(dest, src, imm.m_value);

        } else {

            /*

              li        immTemp, imm

              addu      dest, src, immTemp

            */

            move(imm, immTempRegister);

            m_assembler.addu(dest, src, immTempRegister);

        }

    }

    void add32(Imm32 imm, Address address)

    {

        if (address.offset >= -32768 && address.offset <= 32767

            && !m_fixedWidth) {

            /*

              lw        dataTemp, offset(base)

              li        immTemp, imm

              addu      dataTemp, dataTemp, immTemp

              sw        dataTemp, offset(base)

            */

            m_assembler.lw(dataTempRegister, address.base, address.offset);

            if (!imm.m_isPointer

                && imm.m_value >= -32768 && imm.m_value <= 32767

                && !m_fixedWidth)

                m_assembler.addiu(dataTempRegister, dataTempRegister,

                                  imm.m_value);

            else {

                move(imm, immTempRegister);

                m_assembler.addu(dataTempRegister, dataTempRegister,

                                 immTempRegister);

            }

            m_assembler.sw(dataTempRegister, address.base, address.offset);

        } else {

            /*

              lui       addrTemp, (offset + 0x8000) >> 16

              addu      addrTemp, addrTemp, base

              lw        dataTemp, (offset & 0xffff)(addrTemp)

              li        immtemp, imm

              addu      dataTemp, dataTemp, immTemp

              sw        dataTemp, (offset & 0xffff)(addrTemp)

            */

            m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16);

            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);

            m_assembler.lw(dataTempRegister, addrTempRegister, address.offset);

            if (imm.m_value >= -32768 && imm.m_value <= 32767 && !m_fixedWidth)

                m_assembler.addiu(dataTempRegister, dataTempRegister,

                                  imm.m_value);

            else {

                move(imm, immTempRegister);

                m_assembler.addu(dataTempRegister, dataTempRegister,

                                 immTempRegister);

            }

            m_assembler.sw(dataTempRegister, addrTempRegister, address.offset);

        }

    }

    void add32(Address src, RegisterID dest)

    {

        load32(src, dataTempRegister);

        add32(dataTempRegister, dest);

    }

    void add32(RegisterID src, Address dest)

    {

        if (dest.offset >= -32768 && dest.offset <= 32767 && !m_fixedWidth) {

            /*

              lw        dataTemp, offset(base)

              addu      dataTemp, dataTemp, src

              sw        dataTemp, offset(base)

            */

            m_assembler.lw(dataTempRegister, dest.base, dest.offset);

            m_assembler.addu(dataTempRegister, dataTempRegister, src);

            m_assembler.sw(dataTempRegister, dest.base, dest.offset);

        } else {

            /*

              lui       addrTemp, (offset + 0x8000) >> 16

              addu      addrTemp, addrTemp, base

              lw        dataTemp, (offset & 0xffff)(addrTemp)

              addu      dataTemp, dataTemp, src

              sw        dataTemp, (offset & 0xffff)(addrTemp)

            */

            m_assembler.lui(addrTempRegister, (dest.offset + 0x8000) >> 16);

            m_assembler.addu(addrTempRegister, addrTempRegister, dest.base);

            m_assembler.lw(dataTempRegister, addrTempRegister, dest.offset);

            m_assembler.addu(dataTempRegister, dataTempRegister, src);

            m_assembler.sw(dataTempRegister, addrTempRegister, dest.offset);

        }

    }

    void add32(Imm32 imm, AbsoluteAddress address)

    {

        /*

           li   addrTemp, address

           li   immTemp, imm

           lw   dataTemp, 0(addrTemp)

           addu dataTemp, dataTemp, immTemp

           sw   dataTemp, 0(addrTemp)

        */

        move(ImmPtr(address.m_ptr), addrTempRegister);

        m_assembler.lw(dataTempRegister, addrTempRegister, 0);

        if (!imm.m_isPointer && imm.m_value >= -32768 && imm.m_value <= 32767

            && !m_fixedWidth)

            m_assembler.addiu(dataTempRegister, dataTempRegister, imm.m_value);

        else {

            move(imm, immTempRegister);

            m_assembler.addu(dataTempRegister, dataTempRegister, immTempRegister);

        }

        m_assembler.sw(dataTempRegister, addrTempRegister, 0);

    }

    void and32(RegisterID src, RegisterID dest)

    {

        m_assembler.andInsn(dest, dest, src);

    }

    void and32(Imm32 imm, RegisterID dest)

    {

        if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth)

            move(MIPSRegisters::zero, dest);

        else if (!imm.m_isPointer && imm.m_value > 0 && imm.m_value < 65535

                 && !m_fixedWidth)

            m_assembler.andi(dest, dest, imm.m_value);

        else {

            /*

              li        immTemp, imm

              and       dest, dest, immTemp

            */

            move(imm, immTempRegister);

            m_assembler.andInsn(dest, dest, immTempRegister);

        }

    }

    void lshift32(Imm32 imm, RegisterID dest)

    {

        m_assembler.sll(dest, dest, imm.m_value);

    }

    void lshift32(RegisterID shiftAmount, RegisterID dest)

    {

        m_assembler.sllv(dest, dest, shiftAmount);

    }

    void mul32(RegisterID src, RegisterID dest)

    {

        m_assembler.mul(dest, dest, src);

    }

    void mul32(Imm32 imm, RegisterID src, RegisterID dest)

    {

        if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth)

            move(MIPSRegisters::zero, dest);

        else if (!imm.m_isPointer && imm.m_value == 1 && !m_fixedWidth)

            move(src, dest);

        else {

            /*

                li      dataTemp, imm

                mul     dest, src, dataTemp

            */

            move(imm, dataTempRegister);

            m_assembler.mul(dest, src, dataTempRegister);

        }

    }

    void not32(RegisterID srcDest)

    {

        m_assembler.nor(srcDest, srcDest, MIPSRegisters::zero);

    }

    void or32(RegisterID src, RegisterID dest)

    {

        m_assembler.orInsn(dest, dest, src);

    }

    void or32(Imm32 imm, RegisterID dest)

    {

        if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth)

            return;

        if (!imm.m_isPointer && imm.m_value > 0 && imm.m_value < 65535

            && !m_fixedWidth) {

            m_assembler.ori(dest, dest, imm.m_value);

            return;

        }

        /*

            li      dataTemp, imm

            or      dest, dest, dataTemp

        */

        move(imm, dataTempRegister);

        m_assembler.orInsn(dest, dest, dataTempRegister);

    }

    void rshift32(RegisterID shiftAmount, RegisterID dest)

    {

        m_assembler.srav(dest, dest, shiftAmount);

    }

    void rshift32(Imm32 imm, RegisterID dest)

    {

        m_assembler.sra(dest, dest, imm.m_value);

    }

    void urshift32(RegisterID shiftAmount, RegisterID dest)

    {

        m_assembler.srlv(dest, dest, shiftAmount);

    }

    void urshift32(Imm32 imm, RegisterID dest)

    {

        m_assembler.srl(dest, dest, imm.m_value);

    }

    void sub32(RegisterID src, RegisterID dest)

    {

        m_assembler.subu(dest, dest, src);

    }

    void sub32(Imm32 imm, RegisterID dest)

    {

        if (!imm.m_isPointer && imm.m_value >= -32767 && imm.m_value <= 32768

            && !m_fixedWidth) {

            /*

              addiu     dest, src, imm

            */

            m_assembler.addiu(dest, dest, -imm.m_value);

        } else {

            /*

              li        immTemp, imm

              subu      dest, src, immTemp

            */

            move(imm, immTempRegister);

            m_assembler.subu(dest, dest, immTempRegister);

        }

    }

    void sub32(Imm32 imm, Address address)

    {

        if (address.offset >= -32768 && address.offset <= 32767

            && !m_fixedWidth) {

            /*

              lw        dataTemp, offset(base)

              li        immTemp, imm

              subu      dataTemp, dataTemp, immTemp

              sw        dataTemp, offset(base)

            */

            m_assembler.lw(dataTempRegister, address.base, address.offset);

            if (!imm.m_isPointer

                && imm.m_value >= -32767 && imm.m_value <= 32768

                && !m_fixedWidth)

                m_assembler.addiu(dataTempRegister, dataTempRegister,

                                  -imm.m_value);

            else {

                move(imm, immTempRegister);

                m_assembler.subu(dataTempRegister, dataTempRegister,

                                 immTempRegister);

            }

            m_assembler.sw(dataTempRegister, address.base, address.offset);

        } else {

            /*

              lui       addrTemp, (offset + 0x8000) >> 16

              addu      addrTemp, addrTemp, base

              lw        dataTemp, (offset & 0xffff)(addrTemp)

              li        immtemp, imm

              subu      dataTemp, dataTemp, immTemp

              sw        dataTemp, (offset & 0xffff)(addrTemp)

            */

            m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16);

            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);

            m_assembler.lw(dataTempRegister, addrTempRegister, address.offset);

            if (!imm.m_isPointer

                && imm.m_value >= -32767 && imm.m_value <= 32768

                && !m_fixedWidth)

                m_assembler.addiu(dataTempRegister, dataTempRegister,

                                  -imm.m_value);

            else {

                move(imm, immTempRegister);

                m_assembler.subu(dataTempRegister, dataTempRegister,

                                 immTempRegister);

            }

            m_assembler.sw(dataTempRegister, addrTempRegister, address.offset);

        }

    }

    void sub32(Address src, RegisterID dest)

    {

        load32(src, dataTempRegister);

        sub32(dataTempRegister, dest);

    }

    void sub32(Imm32 imm, AbsoluteAddress address)

    {

        /*

           li   addrTemp, address

           li   immTemp, imm

           lw   dataTemp, 0(addrTemp)

           subu dataTemp, dataTemp, immTemp

           sw   dataTemp, 0(addrTemp)

        */

        move(ImmPtr(address.m_ptr), addrTempRegister);

        m_assembler.lw(dataTempRegister, addrTempRegister, 0);

        if (!imm.m_isPointer && imm.m_value >= -32767 && imm.m_value <= 32768

            && !m_fixedWidth) {

            m_assembler.addiu(dataTempRegister, dataTempRegister,

                              -imm.m_value);

        } else {

            move(imm, immTempRegister);

            m_assembler.subu(dataTempRegister, dataTempRegister, immTempRegister);

        }

        m_assembler.sw(dataTempRegister, addrTempRegister, 0);

    }

    void xor32(RegisterID src, RegisterID dest)

    {

        m_assembler.xorInsn(dest, dest, src);

    }

    void xor32(Imm32 imm, RegisterID dest)

    {

        /*

            li  immTemp, imm

            xor dest, dest, immTemp

        */

        move(imm, immTempRegister);

        m_assembler.xorInsn(dest, dest, immTempRegister);

    }

    void sqrtDouble(FPRegisterID src, FPRegisterID dst)

    {

        m_assembler.sqrtd(dst, src);

    }

    // Memory access operations:

    //

    // Loads are of the form load(address, destination) and stores of the form

    // store(source, address).  The source for a store may be an Imm32.  Address

    // operand objects to loads and store will be implicitly constructed if a

    // register is passed.

    /* Need to use zero-extened load byte for load8.  */

    void load8(ImplicitAddress address, RegisterID dest)

    {

        if (address.offset >= -32768 && address.offset <= 32767

            && !m_fixedWidth)

            m_assembler.lbu(dest, address.base, address.offset);

        else {

            /*

                lui     addrTemp, (offset + 0x8000) >> 16

                addu    addrTemp, addrTemp, base

                lbu     dest, (offset & 0xffff)(addrTemp)

              */

            m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16);

            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);

            m_assembler.lbu(dest, addrTempRegister, address.offset);

        }

    }

    void load32(ImplicitAddress address, RegisterID dest)

    {

        if (address.offset >= -32768 && address.offset <= 32767

            && !m_fixedWidth)

            m_assembler.lw(dest, address.base, address.offset);

        else {

            /*

                lui     addrTemp, (offset + 0x8000) >> 16

                addu    addrTemp, addrTemp, base

                lw      dest, (offset & 0xffff)(addrTemp)

              */

            m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16);

            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);

            m_assembler.lw(dest, addrTempRegister, address.offset);

        }

    }

    void load32(BaseIndex address, RegisterID dest)

    {

        if (address.offset >= -32768 && address.offset <= 32767

            && !m_fixedWidth) {

            /*

                sll     addrTemp, address.index, address.scale

                addu    addrTemp, addrTemp, address.base

                lw      dest, address.offset(addrTemp)

            */

            m_assembler.sll(addrTempRegister, address.index, address.scale);

            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);

            m_assembler.lw(dest, addrTempRegister, address.offset);

        } else {

            /*

                sll     addrTemp, address.index, address.scale

                addu    addrTemp, addrTemp, address.base

                lui     immTemp, (address.offset + 0x8000) >> 16

                addu    addrTemp, addrTemp, immTemp

                lw      dest, (address.offset & 0xffff)(at)

            */

            m_assembler.sll(addrTempRegister, address.index, address.scale);

            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);

            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);

            m_assembler.addu(addrTempRegister, addrTempRegister,

                             immTempRegister);

            m_assembler.lw(dest, addrTempRegister, address.offset);

        }

    }

    void load32WithUnalignedHalfWords(BaseIndex address, RegisterID dest)

    {

        if (address.offset >= -32768 && address.offset <= 32764

            && !m_fixedWidth) {

            /*