Archipelago » qemu

/*

 *  m68k micro operations

 * 

 *  Copyright (c) 2006-2007 CodeSourcery

 *  Written by Paul Brook

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include "exec.h"

#include "m68k-qreg.h"

#ifndef offsetof

#define offsetof(type, field) ((size_t) &((type *)0)->field)

#endif

static long qreg_offsets[] = {

#define DEFO32(name, offset) offsetof(CPUState, offset),

#define DEFR(name, reg, mode) -1,

#define DEFF64(name, offset) offsetof(CPUState, offset),

    0,

#include "qregs.def"

};

#define CPU_FP_STATUS env->fp_status

#define RAISE_EXCEPTION(n) do { \

    env->exception_index = n; \

    cpu_loop_exit(); \

    } while(0)

#define get_op helper_get_op

#define set_op helper_set_op

#define get_opf64 helper_get_opf64

#define set_opf64 helper_set_opf64

uint32_t

get_op(int qreg)

{

    if (qreg >= TARGET_NUM_QREGS) {

        return env->qregs[qreg - TARGET_NUM_QREGS];

    } else if (qreg == QREG_T0) {

        return T0;

    } else {

        return *(uint32_t *)(((long)env) + qreg_offsets[qreg]);

    }

}

void set_op(int qreg, uint32_t val)

{

    if (qreg >= TARGET_NUM_QREGS) {

        env->qregs[qreg - TARGET_NUM_QREGS] = val;

    } else if (qreg == QREG_T0) {

        T0 = val;

    } else {

        *(uint32_t *)(((long)env) + qreg_offsets[qreg]) = val;

    }

}

float64 get_opf64(int qreg)

{

    if (qreg < TARGET_NUM_QREGS) {

        return *(float64 *)(((long)env) + qreg_offsets[qreg]);

    } else {

        return *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS];

    }

}

void set_opf64(int qreg, float64 val)

{

    if (qreg < TARGET_NUM_QREGS) {

        *(float64 *)(((long)env) + qreg_offsets[qreg]) = val;

    } else {

        *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS] = val;

    }

}

#define OP(name) void OPPROTO glue(op_,name) (void)

OP(mov32)

{

    set_op(PARAM1, get_op(PARAM2));

    FORCE_RET();

}

OP(mov32_im)

{

    set_op(PARAM1, PARAM2);

    FORCE_RET();

}

OP(movf64)

{

    set_opf64(PARAM1, get_opf64(PARAM2));

    FORCE_RET();

}

OP(zerof64)

{

    set_opf64(PARAM1, 0);

    FORCE_RET();

}

OP(add32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    set_op(PARAM1, op2 + op3);

    FORCE_RET();

}

OP(sub32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    set_op(PARAM1, op2 - op3);

    FORCE_RET();

}

OP(mul32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    set_op(PARAM1, op2 * op3);

    FORCE_RET();

}

OP(not32)

{

    uint32_t arg = get_op(PARAM2);

    set_op(PARAM1, ~arg);

    FORCE_RET();

}

OP(neg32)

{

    uint32_t arg = get_op(PARAM2);

    set_op(PARAM1, -arg);

    FORCE_RET();

}

OP(bswap32)

{

    uint32_t arg = get_op(PARAM2);

    arg = (arg >> 24) | (arg << 24)

          | ((arg >> 16) & 0xff00) | ((arg << 16) & 0xff0000);

    set_op(PARAM1, arg);

    FORCE_RET();

}

OP(btest)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    if (op1 & op2)

        env->cc_dest &= ~CCF_Z;

    else

        env->cc_dest |= CCF_Z;

    FORCE_RET();

}

OP(ff1)

{

    uint32_t arg = get_op(PARAM2);

    int n;

    for (n = 32; arg; n--)

        arg >>= 1;

    set_op(PARAM1, n);

    FORCE_RET();

}

OP(subx_cc)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    uint32_t res;

    if (env->cc_x) {

        env->cc_x = (op1 <= op2);

        env->cc_op = CC_OP_SUBX;

        res = op1 - (op2 + 1);

    } else {

        env->cc_x = (op1 < op2);

        env->cc_op = CC_OP_SUB;

        res = op1 - op2;

    }

    set_op(PARAM1, res);

    FORCE_RET();

}

OP(addx_cc)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    uint32_t res;

    if (env->cc_x) {

        res = op1 + op2 + 1;

        env->cc_x = (res <= op2);

        env->cc_op = CC_OP_ADDX;

    } else {

        res = op1 + op2;

        env->cc_x = (res < op2);

        env->cc_op = CC_OP_ADD;

    }

    set_op(PARAM1, res);

    FORCE_RET();

}

/* Logic ops.  */

OP(and32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    set_op(PARAM1, op2 & op3);

    FORCE_RET();

}

OP(or32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    set_op(PARAM1, op2 | op3);

    FORCE_RET();

}

OP(xor32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    set_op(PARAM1, op2 ^ op3);

    FORCE_RET();

}

/* Shifts.  */

OP(shl32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    uint32_t result;

    result = op2 << op3;

    set_op(PARAM1, result);

    FORCE_RET();

}

OP(shl_cc)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    uint32_t result;

    result = op1 << op2;

    set_op(PARAM1, result);

    env->cc_x = (op1 << (op2 - 1)) & 1;

    FORCE_RET();

}

OP(shr32)

{

    uint32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    uint32_t result;

    result = op2 >> op3;

    set_op(PARAM1, result);

    FORCE_RET();

}

OP(shr_cc)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    uint32_t result;

    result = op1 >> op2;

    set_op(PARAM1, result);

    env->cc_x = (op1 >> (op2 - 1)) & 1;

    FORCE_RET();

}

OP(sar32)

{

    int32_t op2 = get_op(PARAM2);

    uint32_t op3 = get_op(PARAM3);

    uint32_t result;

    result = op2 >> op3;

    set_op(PARAM1, result);

    FORCE_RET();

}

OP(sar_cc)

{

    int32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    uint32_t result;

    result = op1 >> op2;

    set_op(PARAM1, result);

    env->cc_x = (op1 >> (op2 - 1)) & 1;

    FORCE_RET();

}

/* Value extend.  */

OP(ext8u32)

{

    uint32_t op2 = get_op(PARAM2);

    set_op(PARAM1, (uint8_t)op2);

    FORCE_RET();

}

OP(ext8s32)

{

    uint32_t op2 = get_op(PARAM2);

    set_op(PARAM1, (int8_t)op2);

    FORCE_RET();

}

OP(ext16u32)

{

    uint32_t op2 = get_op(PARAM2);

    set_op(PARAM1, (uint16_t)op2);

    FORCE_RET();

}

OP(ext16s32)

{

    uint32_t op2 = get_op(PARAM2);

    set_op(PARAM1, (int16_t)op2);

    FORCE_RET();

}

OP(flush_flags)

{

    cpu_m68k_flush_flags(env, env->cc_op);

    FORCE_RET();

}

OP(divu)

{

    uint32_t num;

    uint32_t den;

    uint32_t quot;

    uint32_t rem;

    uint32_t flags;

    num = env->div1;

    den = env->div2;

    /* ??? This needs to make sure the throwing location is accurate.  */

    if (den == 0)

        RAISE_EXCEPTION(EXCP_DIV0);

    quot = num / den;

    rem = num % den;

    flags = 0;

    /* Avoid using a PARAM1 of zero.  This breaks dyngen because it uses

       the address of a symbol, and gcc knows symbols can't have address

       zero.  */

    if (PARAM1 == 2 && quot > 0xffff)

        flags |= CCF_V;

    if (quot == 0)

        flags |= CCF_Z;

    else if ((int32_t)quot < 0)

        flags |= CCF_N;

    env->div1 = quot;

    env->div2 = rem;

    env->cc_dest = flags;

    FORCE_RET();

}

OP(divs)

{

    int32_t num;

    int32_t den;

    int32_t quot;

    int32_t rem;

    int32_t flags;

    num = env->div1;

    den = env->div2;

    if (den == 0)

        RAISE_EXCEPTION(EXCP_DIV0);

    quot = num / den;

    rem = num % den;

    flags = 0;

    if (PARAM1 == 2 && quot != (int16_t)quot)

        flags |= CCF_V;

    if (quot == 0)

        flags |= CCF_Z;

    else if (quot < 0)

        flags |= CCF_N;

    env->div1 = quot;

    env->div2 = rem;

    env->cc_dest = flags;

    FORCE_RET();

}

/* Halt is special because it may be a semihosting call.  */

OP(halt)

{

    RAISE_EXCEPTION(EXCP_HALT_INSN);

    FORCE_RET();

}

OP(stop)

{

    env->halted = 1;

    RAISE_EXCEPTION(EXCP_HLT);

    FORCE_RET();

}

OP(raise_exception)

{

    RAISE_EXCEPTION(PARAM1);

    FORCE_RET();

}

/* Floating point comparison sets flags differently to other instructions.  */

OP(sub_cmpf64)

{

    float64 src0;

    float64 src1;

    src0 = get_opf64(PARAM2);

    src1 = get_opf64(PARAM3);

    set_opf64(PARAM1, helper_sub_cmpf64(env, src0, src1));

    FORCE_RET();

}

OP(update_xflag_tst)

{

    uint32_t op1 = get_op(PARAM1);

    env->cc_x = op1;

    FORCE_RET();

}

OP(update_xflag_lt)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    env->cc_x = (op1 < op2);

    FORCE_RET();

}

OP(get_xflag)

{

    set_op(PARAM1, env->cc_x);

    FORCE_RET();

}

OP(logic_cc)

{

    uint32_t op1 = get_op(PARAM1);

    env->cc_dest = op1;

    FORCE_RET();

}

OP(update_cc_add)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    env->cc_dest = op1;

    env->cc_src = op2;

    FORCE_RET();

}

OP(fp_result)

{

    env->fp_result = get_opf64(PARAM1);

    FORCE_RET();

}

OP(set_sr)

{

    env->sr = get_op(PARAM1) & 0xffff;

    m68k_switch_sp(env);

    FORCE_RET();

}

OP(jmp)

{

    GOTO_LABEL_PARAM(1);

}

OP(set_T0_z32)

{

    uint32_t arg = get_op(PARAM1);

    T0 = (arg == 0);

    FORCE_RET();

}

OP(set_T0_nz32)

{

    uint32_t arg = get_op(PARAM1);

    T0 = (arg != 0);

    FORCE_RET();

}

OP(set_T0_s32)

{

    int32_t arg = get_op(PARAM1);

    T0 = (arg > 0);

    FORCE_RET();

}

OP(set_T0_ns32)

{

    int32_t arg = get_op(PARAM1);

    T0 = (arg >= 0);

    FORCE_RET();

}

OP(jmp_T0)

{

    if (T0)

        GOTO_LABEL_PARAM(1);

    FORCE_RET();

}

void OPPROTO op_goto_tb0(void)

{

    GOTO_TB(op_goto_tb0, PARAM1, 0);

}

void OPPROTO op_goto_tb1(void)

{

    GOTO_TB(op_goto_tb1, PARAM1, 1);

}

OP(exit_tb)

{

    EXIT_TB();

}

/* Floating point.  */

OP(f64_to_i32)

{

    set_op(PARAM1, float64_to_int32(get_opf64(PARAM2), &CPU_FP_STATUS));

    FORCE_RET();

}

OP(f64_to_f32)

{

    union {

        float32 f;

        uint32_t i;

    } u;

    u.f = float64_to_float32(get_opf64(PARAM2), &CPU_FP_STATUS);

    set_op(PARAM1, u.i);

    FORCE_RET();

}

OP(i32_to_f64)

{

    set_opf64(PARAM1, int32_to_float64(get_op(PARAM2), &CPU_FP_STATUS));

    FORCE_RET();

}

OP(f32_to_f64)

{

    union {

        float32 f;

        uint32_t i;

    } u;

    u.i = get_op(PARAM2);

    set_opf64(PARAM1, float32_to_float64(u.f, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(absf64)

{

    float64 op0 = get_opf64(PARAM2);

    set_opf64(PARAM1, float64_abs(op0));

    FORCE_RET();

}

OP(chsf64)

{

    float64 op0 = get_opf64(PARAM2);

    set_opf64(PARAM1, float64_chs(op0));

    FORCE_RET();

}

OP(sqrtf64)

{

    float64 op0 = get_opf64(PARAM2);

    set_opf64(PARAM1, float64_sqrt(op0, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(addf64)

{

    float64 op0 = get_opf64(PARAM2);

    float64 op1 = get_opf64(PARAM3);

    set_opf64(PARAM1, float64_add(op0, op1, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(subf64)

{

    float64 op0 = get_opf64(PARAM2);

    float64 op1 = get_opf64(PARAM3);

    set_opf64(PARAM1, float64_sub(op0, op1, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(mulf64)

{

    float64 op0 = get_opf64(PARAM2);

    float64 op1 = get_opf64(PARAM3);

    set_opf64(PARAM1, float64_mul(op0, op1, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(divf64)

{

    float64 op0 = get_opf64(PARAM2);

    float64 op1 = get_opf64(PARAM3);

    set_opf64(PARAM1, float64_div(op0, op1, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(iround_f64)

{

    float64 op0 = get_opf64(PARAM2);

    set_opf64(PARAM1, float64_round_to_int(op0, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(itrunc_f64)

{

    float64 op0 = get_opf64(PARAM2);

    set_opf64(PARAM1, float64_trunc_to_int(op0, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(compare_quietf64)

{

    float64 op0 = get_opf64(PARAM2);

    float64 op1 = get_opf64(PARAM3);

    set_op(PARAM1, float64_compare_quiet(op0, op1, &CPU_FP_STATUS));

    FORCE_RET();

}

OP(movec)

{

    int op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    helper_movec(env, op1, op2);

}

/* Memory access.  */

#define MEMSUFFIX _raw

#include "op_mem.h"

#if !defined(CONFIG_USER_ONLY)

#define MEMSUFFIX _user

#include "op_mem.h"

#define MEMSUFFIX _kernel

#include "op_mem.h"

#endif

/* MAC unit.  */

/* TODO: The MAC instructions use 64-bit arithmetic fairly extensively.

   This results in fairly large ops (and sometimes other issues) on 32-bit

   hosts.  Maybe move most of them into helpers.  */

OP(macmuls)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    int64_t product;

    int64_t res;

    product = (uint64_t)op1 * op2;

    res = (product << 24) >> 24;

    if (res != product) {

        env->macsr |= MACSR_V;

        if (env->macsr & MACSR_OMC) {

            /* Make sure the accumulate operation overflows.  */

            if (product < 0)

                res = ~(1ll << 50);

            else

                res = 1ll << 50;

        }

    }

    env->mactmp = res;

    FORCE_RET();

}

OP(macmulu)

{

    uint32_t op1 = get_op(PARAM1);

    uint32_t op2 = get_op(PARAM2);

    uint64_t product;

    product = (uint64_t)op1 * op2;

    if (product & (0xffffffull << 40)) {

        env->macsr |= MACSR_V;

        if (env->macsr & MACSR_OMC) {

            /* Make sure the accumulate operation overflows.  */

            product = 1ll << 50;

        } else {

            product &= ((1ull << 40) - 1);

        }

    }

    env->mactmp = product;

    FORCE_RET();

}

OP(macmulf)

{

    int32_t op1 = get_op(PARAM1);

    int32_t op2 = get_op(PARAM2);

    uint64_t product;

    uint32_t remainder;

    product = (uint64_t)op1 * op2;

    if (env->macsr & MACSR_RT) {

        remainder = product & 0xffffff;

        product >>= 24;

        if (remainder > 0x800000)

            product++;

        else if (remainder == 0x800000)

            product += (product & 1);

    } else {

        product >>= 24;

    }

    env->mactmp = product;

    FORCE_RET();

}

OP(macshl)

{

    env->mactmp <<= 1;

}

OP(macshr)

{

    env->mactmp >>= 1;

}

OP(macadd)

{

    int acc = PARAM1;

    env->macc[acc] += env->mactmp;

    FORCE_RET();

}

OP(macsub)

{

    int acc = PARAM1;

    env->macc[acc] -= env->mactmp;

    FORCE_RET();

}

OP(macsats)

{

    int acc = PARAM1;

    int64_t sum;

    int64_t result;

    sum = env->macc[acc];

    result = (sum << 16) >> 16;

    if (result != sum) {

        env->macsr |= MACSR_V;

    }

    if (env->macsr & MACSR_V) {

        env->macsr |= MACSR_PAV0 << acc;

        if (env->macsr & MACSR_OMC) {

            /* The result is saturated to 32 bits, despite overflow occuring

               at 48 bits.  Seems weird, but that's what the hardware docs

               say.  */

            result = (result >> 63) ^ 0x7fffffff;

        }

    }

    env->macc[acc] = result;

    FORCE_RET();

}

OP(macsatu)

{

    int acc = PARAM1;

    uint64_t sum;

    sum = env->macc[acc];

    if (sum & (0xffffull << 48)) {

        env->macsr |= MACSR_V;

    }

    if (env->macsr & MACSR_V) {

        env->macsr |= MACSR_PAV0 << acc;

        if (env->macsr & MACSR_OMC) {

            if (sum > (1ull << 53))

                sum = 0;

            else

                sum = (1ull << 48) - 1;

        } else {

            sum &= ((1ull << 48) - 1);

        }

    }

    FORCE_RET();

}

OP(macsatf)

{

    int acc = PARAM1;

    int64_t sum;

    int64_t result;

    sum = env->macc[acc];

    result = (sum << 16) >> 16;

    if (result != sum) {

        env->macsr |= MACSR_V;

    }

    if (env->macsr & MACSR_V) {

        env->macsr |= MACSR_PAV0 << acc;

        if (env->macsr & MACSR_OMC) {

            result = (result >> 63) ^ 0x7fffffffffffll;

        }

    }

    env->macc[acc] = result;

    FORCE_RET();

}

OP(mac_clear_flags)

{

    env->macsr &= ~(MACSR_V | MACSR_Z | MACSR_N | MACSR_EV);

}

OP(mac_set_flags)

{

    int acc = PARAM1;

    uint64_t val;

    val = env->macc[acc];

    if (val == 0)

        env->macsr |= MACSR_Z;

    else if (val & (1ull << 47));

        env->macsr |= MACSR_N;

    if (env->macsr & (MACSR_PAV0 << acc)) {

        env->macsr |= MACSR_V;

    }

    if (env->macsr & MACSR_FI) {

        val = ((int64_t)val) >> 40;

        if (val != 0 && val != -1)

            env->macsr |= MACSR_EV;

    } else if (env->macsr & MACSR_SU) {

        val = ((int64_t)val) >> 32;

        if (val != 0 && val != -1)

            env->macsr |= MACSR_EV;

    } else {

        if ((val >> 32) != 0)

            env->macsr |= MACSR_EV;

    }

    FORCE_RET();

}

OP(get_macf)

{

    int acc = PARAM2;

    int64_t val;

    int rem;

    uint32_t result;

    val = env->macc[acc];

    if (env->macsr & MACSR_SU) {

        /* 16-bit rounding.  */

        rem = val & 0xffffff;

        val = (val >> 24) & 0xffffu;

        if (rem > 0x800000)

            val++;

        else if (rem == 0x800000)

            val += (val & 1);

    } else if (env->macsr & MACSR_RT) {

        /* 32-bit rounding.  */

        rem = val & 0xff;

        val >>= 8;

        if (rem > 0x80)

            val++;

        else if (rem == 0x80)

            val += (val & 1);

    } else {

        /* No rounding.  */

        val >>= 8;

    }

    if (env->macsr & MACSR_OMC) {

        /* Saturate.  */

        if (env->macsr & MACSR_SU) {

            if (val != (uint16_t) val) {

                result = ((val >> 63) ^ 0x7fff) & 0xffff;

            } else {

                result = val & 0xffff;

            }

        } else {

            if (val != (uint32_t)val) {

                result = ((uint32_t)(val >> 63) & 0x7fffffff);

            } else {

                result = (uint32_t)val;

            }

        }

    } else {

        /* No saturation.  */

        if (env->macsr & MACSR_SU) {

            result = val & 0xffff;

        } else {

            result = (uint32_t)val;

        }

    }

    set_op(PARAM1, result);

    FORCE_RET();

}

OP(get_maci)

{

    int acc = PARAM2;

    set_op(PARAM1, (uint32_t)env->macc[acc]);

    FORCE_RET();

}

OP(get_macs)

{

    int acc = PARAM2;

    int64_t val = env->macc[acc];

    uint32_t result;

    if (val == (int32_t)val) {

        result = (int32_t)val;

    } else {

        result = (val >> 61) ^ 0x7fffffff;

    }

    set_op(PARAM1, result);

    FORCE_RET();

}

OP(get_macu)

{

    int acc = PARAM2;

    uint64_t val = env->macc[acc];

    uint32_t result;

    if ((val >> 32) == 0) {

        result = (uint32_t)val;

    } else {

        result = 0xffffffffu;

    }

    set_op(PARAM1, result);

    FORCE_RET();

}