20dcee9483
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2924 c046a42c-6fe2-441c-8c8c-71466251a162
1078 lines
21 KiB
C
1078 lines
21 KiB
C
/*
|
|
* 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)
|
|
{
|
|
int cc_op = PARAM1;
|
|
if (cc_op == CC_OP_DYNAMIC)
|
|
cc_op = env->cc_op;
|
|
cpu_m68k_flush_flags(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);
|
|
m68k_switch_sp(env);
|
|
FORCE_RET();
|
|
}
|
|
|
|
OP(jmp)
|
|
{
|
|
GOTO_LABEL_PARAM(1);
|
|
}
|
|
|
|
/* These ops involve a function call, which probably requires a stack frame
|
|
and breaks things on some hosts. */
|
|
OP(jmp_z32)
|
|
{
|
|
uint32_t arg = get_op(PARAM1);
|
|
if (arg == 0)
|
|
GOTO_LABEL_PARAM(2);
|
|
FORCE_RET();
|
|
}
|
|
|
|
OP(jmp_nz32)
|
|
{
|
|
uint32_t arg = get_op(PARAM1);
|
|
if (arg != 0)
|
|
GOTO_LABEL_PARAM(2);
|
|
FORCE_RET();
|
|
}
|
|
|
|
OP(jmp_s32)
|
|
{
|
|
int32_t arg = get_op(PARAM1);
|
|
if (arg < 0)
|
|
GOTO_LABEL_PARAM(2);
|
|
FORCE_RET();
|
|
}
|
|
|
|
OP(jmp_ns32)
|
|
{
|
|
int32_t arg = get_op(PARAM1);
|
|
if (arg >= 0)
|
|
GOTO_LABEL_PARAM(2);
|
|
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));
|
|
}
|