/*

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

 * Copyright (C) 2010 University of Szeged

 *

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

#define ARMAssembler_h

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

#include "AssemblerBuffer.h"

#include <wtf/Assertions.h>

#include <wtf/Vector.h>

#include <stdint.h>

namespace JSC {

namespace ARMRegisters {

    typedef enum {

        r0,

        r1,

        r2,

        r3,

        r4,

        r5,

        r6,

        r7, wr = r7,   // thumb work register

        r8,

        r9, sb = r9,   // static base

        r10, sl = r10, // stack limit

        r11, fp = r11, // frame pointer

        r12, ip = r12,

        r13, sp = r13,

        r14, lr = r14,

        r15, pc = r15,

    } RegisterID;

    typedef enum {

        s0,

        s1,

        s2,

        s3,

        s4,

        s5,

        s6,

        s7,

        s8,

        s9,

        s10,

        s11,

        s12,

        s13,

        s14,

        s15,

        s16,

        s17,

        s18,

        s19,

        s20,

        s21,

        s22,

        s23,

        s24,

        s25,

        s26,

        s27,

        s28,

        s29,

        s30,

        s31,

    } FPSingleRegisterID;

    typedef enum {

        d0,

        d1,

        d2,

        d3,

        d4,

        d5,

        d6,

        d7,

        d8,

        d9,

        d10,

        d11,

        d12,

        d13,

        d14,

        d15,

        d16,

        d17,

        d18,

        d19,

        d20,

        d21,

        d22,

        d23,

        d24,

        d25,

        d26,

        d27,

        d28,

        d29,

        d30,

        d31,

    } FPDoubleRegisterID;

    typedef enum {

        q0,

        q1,

        q2,

        q3,

        q4,

        q5,

        q6,

        q7,

        q8,

        q9,

        q10,

        q11,

        q12,

        q13,

        q14,

        q15,

        q16,

        q17,

        q18,

        q19,

        q20,

        q21,

        q22,

        q23,

        q24,

        q25,

        q26,

        q27,

        q28,

        q29,

        q30,

        q31,

    } FPQuadRegisterID;

    inline FPSingleRegisterID asSingle(FPDoubleRegisterID reg)

    {

        ASSERT(reg < d16);

        return (FPSingleRegisterID)(reg << 1);

    }

    inline FPDoubleRegisterID asDouble(FPSingleRegisterID reg)

    {

        ASSERT(!(reg & 1));

        return (FPDoubleRegisterID)(reg >> 1);

    }

}

class ARMv7Assembler;

class ARMThumbImmediate {

    friend class ARMv7Assembler;

    typedef uint8_t ThumbImmediateType;

    static const ThumbImmediateType TypeInvalid = 0;

    static const ThumbImmediateType TypeEncoded = 1;

    static const ThumbImmediateType TypeUInt16 = 2;

    typedef union {

        int16_t asInt;

        struct {

            unsigned imm8 : 8;

            unsigned imm3 : 3;

            unsigned i    : 1;

            unsigned imm4 : 4;

        };

        // If this is an encoded immediate, then it may describe a shift, or a pattern.

        struct {

            unsigned shiftValue7 : 7;

            unsigned shiftAmount : 5;

        };

        struct {

            unsigned immediate   : 8;

            unsigned pattern     : 4;

        };

    } ThumbImmediateValue;

    // byte0 contains least significant bit; not using an array to make client code endian agnostic.

    typedef union {

        int32_t asInt;

        struct {

            uint8_t byte0;

            uint8_t byte1;

            uint8_t byte2;

            uint8_t byte3;

        };

    } PatternBytes;

    ALWAYS_INLINE static void countLeadingZerosPartial(uint32_t& value, int32_t& zeros, const int N)

    {

        if (value & ~((1 << N) - 1)) /* check for any of the top N bits (of 2N bits) are set */

            value >>= N;             /* if any were set, lose the bottom N */

        else                         /* if none of the top N bits are set, */

            zeros += N;              /* then we have identified N leading zeros */

    }

    static int32_t countLeadingZeros(uint32_t value)

    {

        if (!value)

            return 32;

        int32_t zeros = 0;

        countLeadingZerosPartial(value, zeros, 16);

        countLeadingZerosPartial(value, zeros, 8);

        countLeadingZerosPartial(value, zeros, 4);

        countLeadingZerosPartial(value, zeros, 2);

        countLeadingZerosPartial(value, zeros, 1);

        return zeros;

    }

    ARMThumbImmediate()

        : m_type(TypeInvalid)

    {

        m_value.asInt = 0;

    }

    ARMThumbImmediate(ThumbImmediateType type, ThumbImmediateValue value)

        : m_type(type)

        , m_value(value)

    {

    }

    ARMThumbImmediate(ThumbImmediateType type, uint16_t value)

        : m_type(TypeUInt16)

    {

        // Make sure this constructor is only reached with type TypeUInt16;

        // this extra parameter makes the code a little clearer by making it

        // explicit at call sites which type is being constructed

        ASSERT_UNUSED(type, type == TypeUInt16);

        m_value.asInt = value;

    }

public:

    static ARMThumbImmediate makeEncodedImm(uint32_t value)

    {

        ThumbImmediateValue encoding;

        encoding.asInt = 0;

        // okay, these are easy.

        if (value < 256) {

            encoding.immediate = value;

            encoding.pattern = 0;

            return ARMThumbImmediate(TypeEncoded, encoding);

        }

        int32_t leadingZeros = countLeadingZeros(value);

        // if there were 24 or more leading zeros, then we'd have hit the (value < 256) case.

        ASSERT(leadingZeros < 24);

        // Given a number with bit fields Z:B:C, where count(Z)+count(B)+count(C) == 32,

        // Z are the bits known zero, B is the 8-bit immediate, C are the bits to check for

        // zero.  count(B) == 8, so the count of bits to be checked is 24 - count(Z).

        int32_t rightShiftAmount = 24 - leadingZeros;

        if (value == ((value >> rightShiftAmount) << rightShiftAmount)) {

            // Shift the value down to the low byte position.  The assign to 

            // shiftValue7 drops the implicit top bit.

            encoding.shiftValue7 = value >> rightShiftAmount;

            // The endoded shift amount is the magnitude of a right rotate.

            encoding.shiftAmount = 8 + leadingZeros;

            return ARMThumbImmediate(TypeEncoded, encoding);

        }

        PatternBytes bytes;

        bytes.asInt = value;

        if ((bytes.byte0 == bytes.byte1) && (bytes.byte0 == bytes.byte2) && (bytes.byte0 == bytes.byte3)) {

            encoding.immediate = bytes.byte0;

            encoding.pattern = 3;

            return ARMThumbImmediate(TypeEncoded, encoding);

        }

        if ((bytes.byte0 == bytes.byte2) && !(bytes.byte1 | bytes.byte3)) {

            encoding.immediate = bytes.byte0;

            encoding.pattern = 1;

            return ARMThumbImmediate(TypeEncoded, encoding);

        }

        if ((bytes.byte1 == bytes.byte3) && !(bytes.byte0 | bytes.byte2)) {

            encoding.immediate = bytes.byte0;

            encoding.pattern = 2;

            return ARMThumbImmediate(TypeEncoded, encoding);

        }

        return ARMThumbImmediate();

    }

    static ARMThumbImmediate makeUInt12(int32_t value)

    {

        return (!(value & 0xfffff000))

            ? ARMThumbImmediate(TypeUInt16, (uint16_t)value)

            : ARMThumbImmediate();

    }

    static ARMThumbImmediate makeUInt12OrEncodedImm(int32_t value)

    {

        // If this is not a 12-bit unsigned it, try making an encoded immediate.

        return (!(value & 0xfffff000))

            ? ARMThumbImmediate(TypeUInt16, (uint16_t)value)

            : makeEncodedImm(value);

    }

    // The 'make' methods, above, return a !isValid() value if the argument

    // cannot be represented as the requested type.  This methods  is called

    // 'get' since the argument can always be represented.

    static ARMThumbImmediate makeUInt16(uint16_t value)

    {

        return ARMThumbImmediate(TypeUInt16, value);

    }

    bool isValid()

    {

        return m_type != TypeInvalid;

    }

    // These methods rely on the format of encoded byte values.

    bool isUInt3() { return !(m_value.asInt & 0xfff8); }

    bool isUInt4() { return !(m_value.asInt & 0xfff0); }

    bool isUInt5() { return !(m_value.asInt & 0xffe0); }

    bool isUInt6() { return !(m_value.asInt & 0xffc0); }

    bool isUInt7() { return !(m_value.asInt & 0xff80); }

    bool isUInt8() { return !(m_value.asInt & 0xff00); }

    bool isUInt9() { return (m_type == TypeUInt16) && !(m_value.asInt & 0xfe00); }

    bool isUInt10() { return (m_type == TypeUInt16) && !(m_value.asInt & 0xfc00); }

    bool isUInt12() { return (m_type == TypeUInt16) && !(m_value.asInt & 0xf000); }

    bool isUInt16() { return m_type == TypeUInt16; }

    uint8_t getUInt3() { ASSERT(isUInt3()); return m_value.asInt; }

    uint8_t getUInt4() { ASSERT(isUInt4()); return m_value.asInt; }

    uint8_t getUInt5() { ASSERT(isUInt5()); return m_value.asInt; }

    uint8_t getUInt6() { ASSERT(isUInt6()); return m_value.asInt; }

    uint8_t getUInt7() { ASSERT(isUInt7()); return m_value.asInt; }

    uint8_t getUInt8() { ASSERT(isUInt8()); return m_value.asInt; }

    uint8_t getUInt9() { ASSERT(isUInt9()); return m_value.asInt; }

    uint8_t getUInt10() { ASSERT(isUInt10()); return m_value.asInt; }

    uint16_t getUInt12() { ASSERT(isUInt12()); return m_value.asInt; }

    uint16_t getUInt16() { ASSERT(isUInt16()); return m_value.asInt; }

    bool isEncodedImm() { return m_type == TypeEncoded; }

private:

    ThumbImmediateType m_type;

    ThumbImmediateValue m_value;

};

class VFPImmediate {

public:

    VFPImmediate(double d)

        : m_value(-1)

    {

        union {

            uint64_t i;

            double d;

        } u;

        u.d = d;

        int sign = (u.i >> 63);

        int exponent = (u.i >> 52) & 0x7ff;

        uint64_t mantissa = u.i & 0x000fffffffffffffull;

        if ((exponent >= 0x3fc) && (exponent <= 0x403) && !(mantissa & 0x0000ffffffffffffull))

            m_value = (sign << 7) | ((exponent & 7) << 4) | (int)(mantissa >> 48);

    }

    bool isValid()

    {

        return m_value != -1;

    }

    uint8_t value()

    {

        return (uint8_t)m_value;

    }

private:

    int m_value;

};

typedef enum {

    SRType_LSL,

    SRType_LSR,

    SRType_ASR,

    SRType_ROR,

    SRType_RRX = SRType_ROR

} ARMShiftType;

class ARMv7Assembler;

class ShiftTypeAndAmount {

    friend class ARMv7Assembler;

public:

    ShiftTypeAndAmount()

    {

        m_u.type = (ARMShiftType)0;

        m_u.amount = 0;

    }

    ShiftTypeAndAmount(ARMShiftType type, unsigned amount)

    {

        m_u.type = type;

        m_u.amount = amount & 31;

    }

    unsigned lo4() { return m_u.lo4; }

    unsigned hi4() { return m_u.hi4; }

private:

    union {

        struct {

            unsigned lo4 : 4;

            unsigned hi4 : 4;

        };

        struct {

            unsigned type   : 2;

            unsigned amount : 5;

        };

    } m_u;

};

class ARMv7Assembler {

public:

    ~ARMv7Assembler()

    {

        ASSERT(m_jumpsToLink.isEmpty());

    }

    typedef ARMRegisters::RegisterID RegisterID;

    typedef ARMRegisters::FPSingleRegisterID FPSingleRegisterID;

    typedef ARMRegisters::FPDoubleRegisterID FPDoubleRegisterID;

    typedef ARMRegisters::FPQuadRegisterID FPQuadRegisterID;

    // (HS, LO, HI, LS) -> (AE, B, A, BE)

    // (VS, VC) -> (O, NO)

    typedef enum {

        ConditionEQ,

        ConditionNE,

        ConditionHS,

        ConditionLO,

        ConditionMI,

        ConditionPL,

        ConditionVS,

        ConditionVC,

        ConditionHI,

        ConditionLS,

        ConditionGE,

        ConditionLT,

        ConditionGT,

        ConditionLE,

        ConditionAL,

        ConditionCS = ConditionHS,

        ConditionCC = ConditionLO,

    } Condition;

    class JmpSrc {

        friend class ARMv7Assembler;

        friend class ARMInstructionFormatter;

    public:

        JmpSrc()

            : m_offset(-1)

        {

        }

    private:

        JmpSrc(int offset)

            : m_offset(offset)

        {

        }

        int m_offset;

    };

    class JmpDst {

        friend class ARMv7Assembler;

        friend class ARMInstructionFormatter;

    public:

        JmpDst()

            : m_offset(-1)

            , m_used(false)

        {

        }

        bool isUsed() const { return m_used; }

        void used() { m_used = true; }

    private:

        JmpDst(int offset)

            : m_offset(offset)

            , m_used(false)

        {

            ASSERT(m_offset == offset);

        }

        int m_offset : 31;

        int m_used : 1;

    };

private:

    struct LinkRecord {