OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity
b01bcae61c
qemu-e2k/target-m68k/op.c
pbrook f090c9d4ad Add strict checking mode for softfp code. 
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3688 c046a42c-6fe2-441c-8c8c-71466251a162
2007-11-18 14:33:24 +00:00

1076 lines
21 KiB
C
Raw Blame History

/*
* 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, float64_zero);
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();
}
OP(clear_mac)
{
int acc = PARAM1;
env->macc[acc] = 0;
env->macsr &= ~(MACSR_PAV0 << acc);
FORCE_RET();
}
OP(move_mac)
{
int dest = PARAM1;
int src = PARAM2;
uint32_t mask;
env->macc[dest] = env->macc[src];
mask = MACSR_PAV0 << dest;
if (env->macsr & (MACSR_PAV0 << src))
env->macsr |= mask;
else
env->macsr &= ~mask;
FORCE_RET();
}
OP(get_mac_extf)
{
uint32_t val;
int acc = PARAM2;
val = env->macc[acc] & 0x00ff;
val = (env->macc[acc] >> 32) & 0xff00;
val |= (env->macc[acc + 1] << 16) & 0x00ff0000;
val |= (env->macc[acc + 1] >> 16) & 0xff000000;
set_op(PARAM1, val);
FORCE_RET();
}
OP(get_mac_exti)
{
uint32_t val;
int acc = PARAM2;
val = (env->macc[acc] >> 32) & 0xffff;
val |= (env->macc[acc + 1] >> 16) & 0xffff0000;
set_op(PARAM1, val);
FORCE_RET();
}
OP(set_macf)
{
int acc = PARAM2;
int32_t val = get_op(PARAM1);
env->macc[acc] = ((int64_t)val) << 8;
env->macsr &= ~(MACSR_PAV0 << acc);
FORCE_RET();
}
OP(set_macs)
{
int acc = PARAM2;
int32_t val = get_op(PARAM1);
env->macc[acc] = val;
env->macsr &= ~(MACSR_PAV0 << acc);
FORCE_RET();
}
OP(set_macu)
{
int acc = PARAM2;
uint32_t val = get_op(PARAM1);
env->macc[acc] = val;
env->macsr &= ~(MACSR_PAV0 << acc);
FORCE_RET();
}
OP(set_mac_extf)
{
int acc = PARAM2;
int32_t val = get_op(PARAM1);
int64_t res;
int32_t tmp;
res = env->macc[acc] & 0xffffffff00ull;
tmp = (int16_t)(val & 0xff00);
res |= ((int64_t)tmp) << 32;
res |= val & 0xff;
env->macc[acc] = res;
res = env->macc[acc + 1] & 0xffffffff00ull;
tmp = (val & 0xff000000);
res |= ((int64_t)tmp) << 16;
res |= (val >> 16) & 0xff;
env->macc[acc + 1] = res;
}
OP(set_mac_exts)
{
int acc = PARAM2;
int32_t val = get_op(PARAM1);
int64_t res;
int32_t tmp;
res = (uint32_t)env->macc[acc];
tmp = (int16_t)val;
res |= ((int64_t)tmp) << 32;
env->macc[acc] = res;
res = (uint32_t)env->macc[acc + 1];
tmp = val & 0xffff0000;
res |= (int64_t)tmp << 16;
env->macc[acc + 1] = res;
}
OP(set_mac_extu)
{
int acc = PARAM2;
int32_t val = get_op(PARAM1);
uint64_t res;
res = (uint32_t)env->macc[acc];
res |= ((uint64_t)(val & 0xffff)) << 32;
env->macc[acc] = res;
res = (uint32_t)env->macc[acc + 1];
res |= (uint64_t)(val & 0xffff0000) << 16;
env->macc[acc + 1] = res;
}
OP(set_macsr)
{
m68k_set_macsr(env, get_op(PARAM1));
}
Reference in New Issue View Git Blame Copy Permalink