yuzu-emu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2024-10-20 05:38:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

target-m68k: introduce byte and word cc_ops

Browse Source 
Backports commit db3d7945ae7992c91cc5705dccf60fec79b24dc4 from qemu
This commit is contained in:
Laurent Vivier 2018-02-28 06:44:46 -05:00 committed by Lioncash
parent 4e257ffda9
commit 3558b93f11
No known key found for this signature in database
GPG Key ID: 4E3C3CC1031BA9C7
3 changed files with 99 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
qemu/target-m68k/cpu.h
View File

@ -176,11 +176,11 @@ typedef enum {
CC_OP_FLAGS,
/* X in cc_x, C = X, N in cc_n, Z in cc_n, V via cc_n/cc_v. */
CC_OP_ADD,
CC_OP_SUB,
CC_OP_ADDB, CC_OP_ADDW, CC_OP_ADDL,
CC_OP_SUBB, CC_OP_SUBW, CC_OP_SUBL,
/* X in cc_x, {N,Z,C,V} via cc_n/cc_v. */
CC_OP_CMP,
CC_OP_CMPB, CC_OP_CMPW, CC_OP_CMPL,
/* X in cc_x, C = 0, V = 0, N in cc_n, Z in cc_n. */
CC_OP_LOGIC,

26
qemu/target-m68k/helper.c
View File

@ -498,31 +498,41 @@ void HELPER(mac_set_flags)(CPUM68KState *env, uint32_t acc)
}
}
#define EXTSIGN(val, index) ( \
(index == 0) ? (int8_t)(val) : ((index == 1) ? (int16_t)(val) : (val)) \
)
#define COMPUTE_CCR(op, x, n, z, v, c) { \
switch (op) { \
case CC_OP_FLAGS: \
/* Everything in place. */ \
break; \
case CC_OP_ADD: \
case CC_OP_ADDB: \
case CC_OP_ADDW: \
case CC_OP_ADDL: \
res = n; \
src2 = v; \
src1 = res - src2; \
src1 = EXTSIGN(res - src2, op - CC_OP_ADDB); \
c = x; \
z = n; \
v = (res ^ src1) & ~(src1 ^ src2); \
break; \
case CC_OP_SUB: \
case CC_OP_SUBB: \
case CC_OP_SUBW: \
case CC_OP_SUBL: \
res = n; \
src2 = v; \
src1 = res + src2; \
src1 = EXTSIGN(res + src2, op - CC_OP_SUBB); \
c = x; \
z = n; \
v = (res ^ src1) & (src1 ^ src2); \
break; \
case CC_OP_CMP: \
case CC_OP_CMPB: \
case CC_OP_CMPW: \
case CC_OP_CMPL: \
src1 = n; \
src2 = v; \
res = src1 - src2; \
res = EXTSIGN(src1 - src2, op - CC_OP_CMPB); \
n = res; \
z = res; \
c = src1 < src2; \
@ -543,16 +553,16 @@ uint32_t cpu_m68k_get_ccr(CPUM68KState *env)
uint32_t res, src1, src2;
x = env->cc_x;
c = env->cc_c;
n = env->cc_n;
z = env->cc_z;
v = env->cc_v;
c = env->cc_c;
COMPUTE_CCR(env->cc_op, x, n, z, v, c);
n = n >> 31;
v = v >> 31;
z = (z == 0);
v = v >> 31;
return x * CCF_X + n * CCF_N + z * CCF_Z + v * CCF_V + c * CCF_C;
}

135
qemu/target-m68k/translate.c
View File

@ -151,6 +151,12 @@ static const uint8_t cc_op_live[CC_OP_NB] = {
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N | CCF_V,
CCF_X | CCF_N,
};
@ -429,6 +435,35 @@ static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, TCGv base)
return add;
}
/* Sign or zero extend a value. */
static inline void gen_ext(DisasContext *s, TCGv res, TCGv val, int opsize, int sign)
{
TCGContext *tcg_ctx = s->uc->tcg_ctx;
switch (opsize) {
case OS_BYTE:
if (sign) {
tcg_gen_ext8s_i32(tcg_ctx, res, val);
} else {
tcg_gen_ext8u_i32(tcg_ctx, res, val);
}
break;
case OS_WORD:
if (sign) {
tcg_gen_ext16s_i32(tcg_ctx, res, val);
} else {
tcg_gen_ext16u_i32(tcg_ctx, res, val);
}
break;
case OS_LONG:
tcg_gen_mov_i32(tcg_ctx, res, val);
break;
default:
g_assert_not_reached();
}
}
/* Evaluate all the CC flags. */
static void gen_flush_flags(DisasContext *s)
@ -440,13 +475,16 @@ static void gen_flush_flags(DisasContext *s)
case CC_OP_FLAGS:
return;
case CC_OP_ADD:
case CC_OP_ADDB:
case CC_OP_ADDW:
case CC_OP_ADDL:
tcg_gen_mov_i32(tcg_ctx, tcg_ctx->QREG_CC_C, tcg_ctx->QREG_CC_X);
tcg_gen_mov_i32(tcg_ctx, tcg_ctx->QREG_CC_Z, tcg_ctx->QREG_CC_N);
/* Compute signed overflow for addition. */
t0 = tcg_temp_new(tcg_ctx);
t1 = tcg_temp_new(tcg_ctx);
tcg_gen_sub_i32(tcg_ctx, t0, tcg_ctx->QREG_CC_N, tcg_ctx->QREG_CC_V);
gen_ext(s, t0, t0, s->cc_op - CC_OP_ADDB, 1);
tcg_gen_xor_i32(tcg_ctx, t1, tcg_ctx->QREG_CC_N, tcg_ctx->QREG_CC_V);
tcg_gen_xor_i32(tcg_ctx, tcg_ctx->QREG_CC_V, tcg_ctx->QREG_CC_V, t0);
tcg_temp_free(tcg_ctx, t0);
@ -454,13 +492,16 @@ static void gen_flush_flags(DisasContext *s)
tcg_temp_free(tcg_ctx, t1);
break;
case CC_OP_SUB:
case CC_OP_SUBB:
case CC_OP_SUBW:
case CC_OP_SUBL:
tcg_gen_mov_i32(tcg_ctx, tcg_ctx->QREG_CC_C, tcg_ctx->QREG_CC_X);
tcg_gen_mov_i32(tcg_ctx, tcg_ctx->QREG_CC_Z, tcg_ctx->QREG_CC_N);
/* Compute signed overflow for subtraction. */
t0 = tcg_temp_new(tcg_ctx);
t1 = tcg_temp_new(tcg_ctx);
tcg_gen_add_i32(tcg_ctx, t0, tcg_ctx->QREG_CC_N, tcg_ctx->QREG_CC_V);
gen_ext(s, t0, t0, s->cc_op - CC_OP_SUBB, 1);
tcg_gen_xor_i32(tcg_ctx, t1, tcg_ctx->QREG_CC_N, tcg_ctx->QREG_CC_V);
tcg_gen_xor_i32(tcg_ctx, tcg_ctx->QREG_CC_V, tcg_ctx->QREG_CC_V, t0);
tcg_temp_free(tcg_ctx, t0);
@ -468,9 +509,12 @@ static void gen_flush_flags(DisasContext *s)
tcg_temp_free(tcg_ctx, t1);
break;
case CC_OP_CMP:
case CC_OP_CMPB:
case CC_OP_CMPW:
case CC_OP_CMPL:
tcg_gen_setcond_i32(tcg_ctx, TCG_COND_LTU, tcg_ctx->QREG_CC_C, tcg_ctx->QREG_CC_N, tcg_ctx->QREG_CC_V);
tcg_gen_sub_i32(tcg_ctx, tcg_ctx->QREG_CC_Z, tcg_ctx->QREG_CC_N, tcg_ctx->QREG_CC_V);
gen_ext(s, tcg_ctx->QREG_CC_Z, tcg_ctx->QREG_CC_Z, s->cc_op - CC_OP_CMPB, 1);
/* Compute signed overflow for subtraction. */
t0 = tcg_temp_new(tcg_ctx);
tcg_gen_xor_i32(tcg_ctx, t0, tcg_ctx->QREG_CC_Z, tcg_ctx->QREG_CC_N);
@ -502,36 +546,7 @@ static void gen_flush_flags(DisasContext *s)
s->cc_op_synced = 1;
}
/* Sign or zero extend a value. */
static inline void gen_ext(DisasContext *s, TCGv res, TCGv val, int opsize, int sign)
{
TCGContext *tcg_ctx = s->uc->tcg_ctx;
switch (opsize) {
case OS_BYTE:
if (sign) {
tcg_gen_ext8s_i32(tcg_ctx, res, val);
} else {
tcg_gen_ext8u_i32(tcg_ctx, res, val);
}
break;
case OS_WORD:
if (sign) {
tcg_gen_ext16s_i32(tcg_ctx, res, val);
} else {
tcg_gen_ext16u_i32(tcg_ctx, res, val);
}
break;
case OS_LONG:
tcg_gen_mov_i32(tcg_ctx, res, val);
break;
default:
g_assert_not_reached();
}
}
static TCGv gen_extend(DisasContext *s, TCGv val, int opsize, int sign)
static inline TCGv gen_extend(DisasContext *s, TCGv val, int opsize, int sign)
{
TCGv tmp;
TCGContext *tcg_ctx = s->uc->tcg_ctx;
@ -553,10 +568,10 @@ static void gen_logic_cc(DisasContext *s, TCGv val, int opsize)
set_cc_op(s, CC_OP_LOGIC);
}
static void gen_update_cc_add(DisasContext *s, TCGv dest, TCGv src)
static void gen_update_cc_add(DisasContext *s, TCGv dest, TCGv src, int opsize)
{
TCGContext *tcg_ctx = s->uc->tcg_ctx;
tcg_gen_mov_i32(tcg_ctx, tcg_ctx->QREG_CC_N, dest);
gen_ext(s, tcg_ctx->QREG_CC_N, dest, opsize, 1);
tcg_gen_mov_i32(tcg_ctx, tcg_ctx->QREG_CC_V, src);
}
@ -814,7 +829,7 @@ static void gen_cc_cond(DisasCompare *c, DisasContext *s, int cond)
CCOp op = s->cc_op;
/* The CC_OP_CMP form can handle most normal comparisons directly. */
if (op == CC_OP_CMP) {
if (op == CC_OP_CMPB || op == CC_OP_CMPW || op == CC_OP_CMPL) {
c->g1 = c->g2 = 1;
c->v1 = tcg_ctx->QREG_CC_N;
c->v2 = tcg_ctx->QREG_CC_V;
@ -837,6 +852,7 @@ static void gen_cc_cond(DisasCompare *c, DisasContext *s, int cond)
c->v2 = tcg_const_i32(tcg_ctx, 0);
c->v1 = tmp = tcg_temp_new(tcg_ctx);
tcg_gen_sub_i32(tcg_ctx, tmp, tcg_ctx->QREG_CC_N, tcg_ctx->QREG_CC_V);
gen_ext(s, tmp, tmp, op - CC_OP_CMPB, 1);
/* fallthru */
case 12: /* GE */
case 13: /* LT */
@ -880,7 +896,9 @@ static void gen_cc_cond(DisasCompare *c, DisasContext *s, int cond)
case 10: /* PL (!N) */
case 11: /* MI (N) */
/* Several cases represent N normally. */
if (op == CC_OP_ADD || op == CC_OP_SUB || op == CC_OP_LOGIC) {
if (op == CC_OP_ADDB || op == CC_OP_ADDW || op == CC_OP_ADDL ||
op == CC_OP_SUBB || op == CC_OP_SUBW || op == CC_OP_SUBL ||
op == CC_OP_LOGIC) {
c->v1 = tcg_ctx->QREG_CC_N;
tcond = TCG_COND_LT;
goto done;
@ -889,7 +907,9 @@ static void gen_cc_cond(DisasCompare *c, DisasContext *s, int cond)
case 6: /* NE (!Z) */
case 7: /* EQ (Z) */
/* Some cases fold Z into N. */
if (op == CC_OP_ADD || op == CC_OP_SUB || op == CC_OP_LOGIC) {
if (op == CC_OP_ADDB || op == CC_OP_ADDW || op == CC_OP_ADDL ||
op == CC_OP_SUBB || op == CC_OP_SUBW || op == CC_OP_SUBL ||
op == CC_OP_LOGIC) {
tcond = TCG_COND_EQ;
c->v1 = tcg_ctx->QREG_CC_N;
goto done;
@ -898,7 +918,8 @@ static void gen_cc_cond(DisasCompare *c, DisasContext *s, int cond)
case 4: /* CC (!C) */
case 5: /* CS (C) */
/* Some cases fold C into X. */
if (op == CC_OP_ADD || op == CC_OP_SUB) {
if (op == CC_OP_ADDB || op == CC_OP_ADDW || op == CC_OP_ADDL ||
op == CC_OP_ADDB || op == CC_OP_ADDW || op == CC_OP_ADDL) {
tcond = TCG_COND_NE;
c->v1 = tcg_ctx->QREG_CC_X;
goto done;
@ -1259,13 +1280,13 @@ DISAS_INSN(addsub)
if (add) {
tcg_gen_add_i32(tcg_ctx, dest, tmp, src);
tcg_gen_setcond_i32(tcg_ctx, TCG_COND_LTU, tcg_ctx->QREG_CC_X, dest, src);
set_cc_op(s, CC_OP_ADD);
set_cc_op(s, CC_OP_ADDL);
} else {
tcg_gen_setcond_i32(tcg_ctx, TCG_COND_LTU, tcg_ctx->QREG_CC_X, tmp, src);
tcg_gen_sub_i32(tcg_ctx, dest, tmp, src);
set_cc_op(s, CC_OP_SUB);
set_cc_op(s, CC_OP_SUBL);
}
gen_update_cc_add(s, dest, src);
gen_update_cc_add(s, dest, src, OS_LONG);
if (insn & 0x100) {
DEST_EA(env, insn, OS_LONG, dest, &addr);
} else {
@ -1473,23 +1494,23 @@ DISAS_INSN(arith_im)
tcg_gen_mov_i32(tcg_ctx, dest, src1);
tcg_gen_setcondi_i32(tcg_ctx, TCG_COND_LTU, tcg_ctx->QREG_CC_X, dest, im);
tcg_gen_subi_i32(tcg_ctx, dest, dest, im);
gen_update_cc_add(s, dest, tcg_const_i32(tcg_ctx, im));
set_cc_op(s, CC_OP_SUB);
gen_update_cc_add(s, dest, tcg_const_i32(tcg_ctx, im), OS_LONG);
set_cc_op(s, CC_OP_SUBL);
break;
case 3: /* addi */
tcg_gen_mov_i32(tcg_ctx, dest, src1);
tcg_gen_addi_i32(tcg_ctx, dest, dest, im);
gen_update_cc_add(s, dest, tcg_const_i32(tcg_ctx, im));
gen_update_cc_add(s, dest, tcg_const_i32(tcg_ctx, im), OS_LONG);
tcg_gen_setcondi_i32(tcg_ctx, TCG_COND_LTU, tcg_ctx->QREG_CC_X, dest, im);
set_cc_op(s, CC_OP_ADD);
set_cc_op(s, CC_OP_ADDL);
break;
case 5: /* eori */
tcg_gen_xori_i32(tcg_ctx, dest, src1, im);
gen_logic_cc(s, dest, OS_LONG);
break;
case 6: /* cmpi */
gen_update_cc_add(s, src1, tcg_const_i32(tcg_ctx, im));
set_cc_op(s, CC_OP_CMP);
gen_update_cc_add(s, src1, tcg_const_i32(tcg_ctx, im), OS_LONG);
set_cc_op(s, CC_OP_CMPL);
break;
default:
abort();
@ -1651,9 +1672,9 @@ DISAS_INSN(neg)
src1 = tcg_temp_new(tcg_ctx);
tcg_gen_mov_i32(tcg_ctx, src1, reg);
tcg_gen_neg_i32(tcg_ctx, reg, src1);
gen_update_cc_add(s, reg, src1);
gen_update_cc_add(s, reg, src1, OS_LONG);
tcg_gen_setcondi_i32(tcg_ctx, TCG_COND_NE, tcg_ctx->QREG_CC_X, src1, 0);
set_cc_op(s, CC_OP_SUB);
set_cc_op(s, CC_OP_SUBL);
}
static void gen_set_sr_im(DisasContext *s, uint16_t val, int ccr_only)
@ -1936,13 +1957,13 @@ DISAS_INSN(addsubq)
if (insn & 0x0100) {
tcg_gen_setcond_i32(tcg_ctx, TCG_COND_LTU, tcg_ctx->QREG_CC_X, dest, src2);
tcg_gen_sub_i32(tcg_ctx, dest, dest, src2);
set_cc_op(s, CC_OP_SUB);
set_cc_op(s, CC_OP_SUBL);
} else {
tcg_gen_add_i32(tcg_ctx, dest, dest, src2);
tcg_gen_setcond_i32(tcg_ctx, TCG_COND_LTU, tcg_ctx->QREG_CC_X, dest, src2);
set_cc_op(s, CC_OP_ADD);
set_cc_op(s, CC_OP_ADDL);
}
gen_update_cc_add(s, dest, src2);
gen_update_cc_add(s, dest, src2, OS_LONG);
}
DEST_EA(env, insn, OS_LONG, dest, &addr);
}
@ -2161,8 +2182,8 @@ DISAS_INSN(cmp)
opsize = insn_opsize(insn);
SRC_EA(env, src, opsize, -1, NULL);
reg = DREG(insn, 9);
gen_update_cc_add(s, reg, src);
set_cc_op(s, CC_OP_CMP);
gen_update_cc_add(s, reg, src, OS_LONG);
set_cc_op(s, CC_OP_CMPL);
}
DISAS_INSN(cmpa)
@ -2179,8 +2200,8 @@ DISAS_INSN(cmpa)
}
SRC_EA(env, src, opsize, 1, NULL);
reg = AREG(insn, 9);
gen_update_cc_add(s, reg, src);
set_cc_op(s, CC_OP_CMP);
gen_update_cc_add(s, reg, src, OS_LONG);
set_cc_op(s, CC_OP_CMPL);
}
DISAS_INSN(eor)