yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2025-01-22 22:11:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

target-m68k: allow to update flags with operation on words and bytes

Browse source 
Backports commit 5dbb6784b7e2b833c036b4df58aa07067e35f476 from qemu
This commit is contained in:
Laurent Vivier 2018-02-27 08:46:36 -05:00 committed by Lioncash
parent f069762b61
commit b079255576
No known key found for this signature in database
GPG key ID: 4E3C3CC1031BA9C7
3 changed files with 150 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
qemu/target-m68k/cpu.h
View file

@ -170,13 +170,23 @@ void cpu_m68k_flush_flags(CPUM68KState *, int);
enum {
CC_OP_DYNAMIC, /* Use env->cc_op */
CC_OP_FLAGS, /* CC_DEST = CVZN, CC_SRC = unused */
CC_OP_LOGICB, /* CC_DEST = result, CC_SRC = unused */
CC_OP_LOGICW, /* CC_DEST = result, CC_SRC = unused */
CC_OP_LOGIC, /* CC_DEST = result, CC_SRC = unused */
CC_OP_ADDB, /* CC_DEST = result, CC_SRC = source */
CC_OP_ADDW, /* CC_DEST = result, CC_SRC = source */
CC_OP_ADD, /* CC_DEST = result, CC_SRC = source */
CC_OP_SUBB, /* CC_DEST = result, CC_SRC = source */
CC_OP_SUBW, /* CC_DEST = result, CC_SRC = source */
CC_OP_SUB, /* CC_DEST = result, CC_SRC = source */
CC_OP_CMPB, /* CC_DEST = result, CC_SRC = source */
CC_OP_CMPW, /* CC_DEST = result, CC_SRC = source */
CC_OP_ADDXB, /* CC_DEST = result, CC_SRC = source */
CC_OP_ADDXW, /* CC_DEST = result, CC_SRC = source */
CC_OP_ADDX, /* CC_DEST = result, CC_SRC = source */
CC_OP_SUBXB, /* CC_DEST = result, CC_SRC = source */
CC_OP_SUBXW, /* CC_DEST = result, CC_SRC = source */
CC_OP_SUBX, /* CC_DEST = result, CC_SRC = source */
CC_OP_SHIFTB, /* CC_DEST = result, CC_SRC = carry */
CC_OP_SHIFTW, /* CC_DEST = result, CC_SRC = carry */
CC_OP_SHIFT, /* CC_DEST = result, CC_SRC = carry */
};

137
qemu/target-m68k/helper.c
View file

@ -54,22 +54,63 @@ void cpu_m68k_flush_flags(CPUM68KState *env, int cc_op)
uint32_t dest;
uint32_t tmp;
#define HIGHBIT 0x80000000u
#define HIGHBIT(type) (1u << (sizeof(type) * 8 - 1))
#define SET_NZ(x) do { \
if ((x) == 0) \
flags |= CCF_Z; \
else if ((int32_t)(x) < 0) \
flags |= CCF_N; \
#define SET_NZ(x, type) do { \
if ((type)(x) == 0) { \
flags |= CCF_Z; \
} else if ((type)(x) < 0) { \
flags |= CCF_N; \
} \
} while (0)
#define SET_FLAGS_SUB(type, utype) do { \
SET_NZ((type)dest); \
tmp = dest + src; \
if ((utype) tmp < (utype) src) \
flags |= CCF_C; \
if ((1u << (sizeof(type) * 8 - 1)) & (tmp ^ dest) & (tmp ^ src)) \
flags |= CCF_V; \
SET_NZ(dest, type); \
tmp = dest + src; \
if ((utype) tmp < (utype) src) { \
flags |= CCF_C; \
} \
if (HIGHBIT(type) & (tmp ^ dest) & (tmp ^ src)) { \
flags |= CCF_V; \
} \
} while (0)
#define SET_FLAGS_ADD(type, utype) do { \
SET_NZ(dest, type); \
if ((utype) dest < (utype) src) { \
flags |= CCF_C; \
} \
tmp = dest - src; \
if (HIGHBIT(type) & (src ^ dest) & ~(tmp ^ src)) { \
flags |= CCF_V; \
} \
} while (0)
#define SET_FLAGS_ADDX(type, utype) do { \
SET_NZ(dest, type); \
if ((utype) dest <= (utype) src) { \
flags |= CCF_C; \
} \
tmp = dest - src - 1; \
if (HIGHBIT(type) & (src ^ dest) & ~(tmp ^ src)) { \
flags |= CCF_V; \
} \
} while (0)
#define SET_FLAGS_SUBX(type, utype) do { \
SET_NZ(dest, type); \
tmp = dest + src + 1; \
if ((utype) tmp <= (utype) src) { \
flags |= CCF_C; \
} \
if (HIGHBIT(type) & (tmp ^ dest) & (tmp ^ src)) { \
flags |= CCF_V; \
} \
} while (0)
#define SET_FLAGS_SHIFT(type) do { \
SET_NZ(dest, type); \
flags |= src; \
} while (0)
flags = 0;
@ -79,46 +120,66 @@ void cpu_m68k_flush_flags(CPUM68KState *env, int cc_op)
case CC_OP_FLAGS:
flags = dest;
break;
case CC_OP_LOGICB:
SET_NZ(dest, int8_t);
goto set_x;
break;
case CC_OP_LOGICW:
SET_NZ(dest, int16_t);
goto set_x;
break;
case CC_OP_LOGIC:
SET_NZ(dest);
SET_NZ(dest, int32_t);
set_x:
if (!m68k_feature(env, M68K_FEATURE_M68000)) {
/* Unlike m68k, coldfire always clears the overflow bit. */
env->cc_x = 0;
}
break;
case CC_OP_ADDB:
SET_FLAGS_ADD(int8_t, uint8_t);
break;
case CC_OP_ADDW:
SET_FLAGS_ADD(int16_t, uint16_t);
break;
case CC_OP_ADD:
SET_NZ(dest);
if (dest < src)
flags |= CCF_C;
tmp = dest - src;
if (HIGHBIT & (src ^ dest) & ~(tmp ^ src))
flags |= CCF_V;
SET_FLAGS_ADD(int32_t, uint32_t);
break;
case CC_OP_SUBB:
SET_FLAGS_SUB(int8_t, uint8_t);
break;
case CC_OP_SUBW:
SET_FLAGS_SUB(int16_t, uint16_t);
break;
case CC_OP_SUB:
SET_FLAGS_SUB(int32_t, uint32_t);
break;
case CC_OP_CMPB:
SET_FLAGS_SUB(int8_t, uint8_t);
case CC_OP_ADDXB:
SET_FLAGS_ADDX(int8_t, uint8_t);
break;
case CC_OP_CMPW:
SET_FLAGS_SUB(int16_t, uint16_t);
case CC_OP_ADDXW:
SET_FLAGS_ADDX(int16_t, uint16_t);
break;
case CC_OP_ADDX:
SET_NZ(dest);
if (dest <= src)
flags |= CCF_C;
tmp = dest - src - 1;
if (HIGHBIT & (src ^ dest) & ~(tmp ^ src))
flags |= CCF_V;
SET_FLAGS_ADDX(int32_t, uint32_t);
break;
case CC_OP_SUBXB:
SET_FLAGS_SUBX(int8_t, uint8_t);
break;
case CC_OP_SUBXW:
SET_FLAGS_SUBX(int16_t, uint16_t);
break;
case CC_OP_SUBX:
SET_NZ(dest);
tmp = dest + src + 1;
if (tmp <= src)
flags |= CCF_C;
if (HIGHBIT & (tmp ^ dest) & (tmp ^ src))
flags |= CCF_V;
SET_FLAGS_SUBX(int32_t, uint32_t);
break;
case CC_OP_SHIFTB:
SET_FLAGS_SHIFT(int8_t);
break;
case CC_OP_SHIFTW:
SET_FLAGS_SHIFT(int16_t);
break;
case CC_OP_SHIFT:
SET_NZ(dest);
if (src)
flags |= CCF_C;
SET_FLAGS_SHIFT(int32_t);
break;
default:
cpu_abort(CPU(cpu), "Bad CC_OP %d", cc_op);

82
qemu/target-m68k/translate.c
View file

@ -402,11 +402,24 @@ static inline void gen_flush_flags(DisasContext *s)
s->cc_op = CC_OP_FLAGS;
}
static void gen_logic_cc(DisasContext *s, TCGv val)
#define SET_CC_OP(opsize, op) do { \
switch (opsize) { \
case OS_BYTE: \
s->cc_op = CC_OP_##op##B; break; \
case OS_WORD: \
s->cc_op = CC_OP_##op##W; break; \
case OS_LONG: \
s->cc_op = CC_OP_##op; break; \
default: \
abort(); \
} \
} while (0)
static void gen_logic_cc(DisasContext *s, TCGv val, int opsize)
{
TCGContext *tcg_ctx = s->uc->tcg_ctx;
tcg_gen_mov_i32(tcg_ctx, tcg_ctx->QREG_CC_DEST, val);
s->cc_op = CC_OP_LOGIC;
SET_CC_OP(opsize, LOGIC);
}
static void gen_update_cc_add(DisasContext *s, TCGv dest, TCGv src)
@ -927,8 +940,7 @@ DISAS_INSN(mulw)
SRC_EA(env, src, OS_WORD, sign, NULL);
tcg_gen_mul_i32(tcg_ctx, tmp, tmp, src);
tcg_gen_mov_i32(tcg_ctx, reg, tmp);
/* Unlike m68k, coldfire always clears the overflow bit. */
gen_logic_cc(s, tmp);
gen_logic_cc(s, tmp, OS_WORD);
}
DISAS_INSN(divw)
@ -1103,7 +1115,7 @@ DISAS_INSN(sats)
reg = DREG(insn, 0);
gen_flush_flags(s);
gen_helper_sats(tcg_ctx, reg, reg, tcg_ctx->QREG_CC_DEST);
gen_logic_cc(s, reg);
gen_logic_cc(s, reg, OS_LONG);
}
static void gen_push(DisasContext *s, TCGv val)
@ -1232,11 +1244,11 @@ DISAS_INSN(arith_im)
switch (op) {
case 0: /* ori */
tcg_gen_ori_i32(tcg_ctx, dest, src1, im);
gen_logic_cc(s, dest);
gen_logic_cc(s, dest, OS_LONG);
break;
case 1: /* andi */
tcg_gen_andi_i32(tcg_ctx, dest, src1, im);
gen_logic_cc(s, dest);
gen_logic_cc(s, dest, OS_LONG);
break;
case 2: /* subi */
tcg_gen_mov_i32(tcg_ctx, dest, src1);
@ -1254,7 +1266,7 @@ DISAS_INSN(arith_im)
break;
case 5: /* eori */
tcg_gen_xori_i32(tcg_ctx, dest, src1, im);
gen_logic_cc(s, dest);
gen_logic_cc(s, dest, OS_LONG);
break;
case 6: /* cmpi */
tcg_gen_mov_i32(tcg_ctx, dest, src1);
@ -1313,7 +1325,7 @@ DISAS_INSN(move)
dest_ea = ((insn >> 9) & 7) | (op << 3);
DEST_EA(env, dest_ea, opsize, src, NULL);
/* This will be correct because loads sign extend. */
gen_logic_cc(s, src);
gen_logic_cc(s, src, opsize);
}
}
@ -1349,7 +1361,7 @@ DISAS_INSN(clr)
opsize = insn_opsize(insn);
DEST_EA(env, insn, opsize, tcg_const_i32(tcg_ctx, 0), NULL);
gen_logic_cc(s, tcg_const_i32(tcg_ctx, 0));
gen_logic_cc(s, tcg_const_i32(tcg_ctx, 0), opsize);
}
static TCGv gen_get_ccr(DisasContext *s)
@ -1442,7 +1454,7 @@ DISAS_INSN(not)
reg = DREG(insn, 0);
tcg_gen_not_i32(tcg_ctx, reg, reg);
gen_logic_cc(s, reg);
gen_logic_cc(s, reg, OS_LONG);
}
DISAS_INSN(swap)
@ -1458,7 +1470,7 @@ DISAS_INSN(swap)
tcg_gen_shli_i32(tcg_ctx, src1, reg, 16);
tcg_gen_shri_i32(tcg_ctx, src2, reg, 16);
tcg_gen_or_i32(tcg_ctx, reg, src1, src2);
gen_logic_cc(s, reg);
gen_logic_cc(s, reg, OS_LONG);
}
DISAS_INSN(pea)
@ -1492,7 +1504,7 @@ DISAS_INSN(ext)
gen_partset_reg(s, OS_WORD, reg, tmp);
else
tcg_gen_mov_i32(tcg_ctx, reg, tmp);
gen_logic_cc(s, tmp);
gen_logic_cc(s, tmp, OS_LONG);
}
DISAS_INSN(tst)
@ -1503,7 +1515,7 @@ DISAS_INSN(tst)
opsize = insn_opsize(insn);
SRC_EA(env, tmp, opsize, 1, NULL);
gen_logic_cc(s, tmp);
gen_logic_cc(s, tmp, opsize);
}
DISAS_INSN(pulse)
@ -1526,7 +1538,7 @@ DISAS_INSN(tas)
dest = tcg_temp_new(tcg_ctx);
SRC_EA(env, src1, OS_BYTE, 1, &addr);
gen_logic_cc(s, src1);
gen_logic_cc(s, src1, OS_BYTE);
tcg_gen_ori_i32(tcg_ctx, dest, src1, 0x80);
DEST_EA(env, insn, OS_BYTE, dest, &addr);
}
@ -1552,7 +1564,7 @@ DISAS_INSN(mull)
tcg_gen_mul_i32(tcg_ctx, dest, src1, reg);
tcg_gen_mov_i32(tcg_ctx, reg, dest);
/* Unlike m68k, coldfire always clears the overflow bit. */
gen_logic_cc(s, dest);
gen_logic_cc(s, dest, OS_LONG);
}
DISAS_INSN(link)
@ -1717,7 +1729,7 @@ DISAS_INSN(moveq)
val = (int8_t)insn;
tcg_gen_movi_i32(tcg_ctx, DREG(insn, 9), val);
gen_logic_cc(s, tcg_const_i32(tcg_ctx, val));
gen_logic_cc(s, tcg_const_i32(tcg_ctx, val), OS_LONG);
}
DISAS_INSN(mvzs)
@ -1734,7 +1746,7 @@ DISAS_INSN(mvzs)
SRC_EA(env, src, opsize, (insn & 0x80) == 0, NULL);
reg = DREG(insn, 9);
tcg_gen_mov_i32(tcg_ctx, reg, src);
gen_logic_cc(s, src);
gen_logic_cc(s, src, opsize);
}
DISAS_INSN(or)
@ -1756,7 +1768,7 @@ DISAS_INSN(or)
tcg_gen_or_i32(tcg_ctx, dest, src, reg);
tcg_gen_mov_i32(tcg_ctx, reg, dest);
}
gen_logic_cc(s, dest);
gen_logic_cc(s, dest, OS_LONG);
}
DISAS_INSN(suba)
@ -1792,41 +1804,25 @@ DISAS_INSN(mov3q)
if (val == 0)
val = -1;
src = tcg_const_i32(tcg_ctx, val);
gen_logic_cc(s, src);
gen_logic_cc(s, src, OS_LONG);
DEST_EA(env, insn, OS_LONG, src, NULL);
}
DISAS_INSN(cmp)
{
TCGContext *tcg_ctx = s->uc->tcg_ctx;
int op;
TCGv src;
TCGv reg;
TCGv dest;
int opsize;
op = (insn >> 6) & 3;
switch (op) {
case 0: /* cmp.b */
opsize = OS_BYTE;
s->cc_op = CC_OP_CMPB;
break;
case 1: /* cmp.w */
opsize = OS_WORD;
s->cc_op = CC_OP_CMPW;
break;
case 2: /* cmp.l */
opsize = OS_LONG;
s->cc_op = CC_OP_SUB;
break;
default:
abort();
}
SRC_EA(env, src, opsize, 1, NULL);
opsize = insn_opsize(insn);
SRC_EA(env, src, opsize, -1, NULL);
reg = DREG(insn, 9);
dest = tcg_temp_new(tcg_ctx);
tcg_gen_sub_i32(tcg_ctx, dest, reg, src);
gen_update_cc_add(s, dest, src);
SET_CC_OP(opsize, SUB);
}
DISAS_INSN(cmpa)
@ -1847,7 +1843,7 @@ DISAS_INSN(cmpa)
dest = tcg_temp_new(tcg_ctx);
tcg_gen_sub_i32(tcg_ctx, dest, reg, src);
gen_update_cc_add(s, dest, src);
s->cc_op = CC_OP_SUB;
SET_CC_OP(OS_LONG, SUB);
}
DISAS_INSN(eor)
@ -1862,7 +1858,7 @@ DISAS_INSN(eor)
reg = DREG(insn, 9);
dest = tcg_temp_new(tcg_ctx);
tcg_gen_xor_i32(tcg_ctx, dest, src, reg);
gen_logic_cc(s, dest);
gen_logic_cc(s, dest, OS_LONG);
DEST_EA(env, insn, OS_LONG, dest, &addr);
}
@ -1885,7 +1881,7 @@ DISAS_INSN(and)
tcg_gen_and_i32(tcg_ctx, dest, src, reg);
tcg_gen_mov_i32(tcg_ctx, reg, dest);
}
gen_logic_cc(s, dest);
gen_logic_cc(s, dest, OS_LONG);
}
DISAS_INSN(adda)
@ -1965,7 +1961,7 @@ DISAS_INSN(ff1)
TCGContext *tcg_ctx = s->uc->tcg_ctx;
TCGv reg;
reg = DREG(insn, 0);
gen_logic_cc(s, reg);
gen_logic_cc(s, reg, OS_LONG);
gen_helper_ff1(tcg_ctx, reg, reg);
}