mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

target-i386: Don't reference ENV through most of cc helpers

Browse Source 
In preparation for making this a const helper.

By using the proper types in the parameters to the helper functions,
we get to avoid quite a lot of subsequent casting.

Signed-off-by: Richard Henderson <rth@twiddle.net>
This commit is contained in:
Richard Henderson 2013-01-23 16:06:38 -08:00
parent a3251186fc
commit 8601c0b6c5
2 changed files with 189 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
target-i386/cc_helper.c
View File

@ -75,125 +75,108 @@ const uint8_t parity_table[256] = {
#endif #endif
static int compute_all_eflags(CPUX86State *env)
{
return CC_SRC;
}
static int compute_c_eflags(CPUX86State *env)
{
return CC_SRC & CC_C;
}
uint32_t helper_cc_compute_all(CPUX86State *env, int op) uint32_t helper_cc_compute_all(CPUX86State *env, int op)
{ {
target_ulong dst = CC_DST, src1 = CC_SRC;
switch (op) { switch (op) {
default: /* should never happen */ default: /* should never happen */
return 0; return 0;
case CC_OP_EFLAGS: case CC_OP_EFLAGS:
return compute_all_eflags(env); return src1;
case CC_OP_MULB: case CC_OP_MULB:
return compute_all_mulb(env); return compute_all_mulb(dst, src1);
case CC_OP_MULW: case CC_OP_MULW:
return compute_all_mulw(env); return compute_all_mulw(dst, src1);
case CC_OP_MULL: case CC_OP_MULL:
return compute_all_mull(env); return compute_all_mull(dst, src1);
case CC_OP_ADDB: case CC_OP_ADDB:
return compute_all_addb(env); return compute_all_addb(dst, src1);
case CC_OP_ADDW: case CC_OP_ADDW:
return compute_all_addw(env); return compute_all_addw(dst, src1);
case CC_OP_ADDL: case CC_OP_ADDL:
return compute_all_addl(env); return compute_all_addl(dst, src1);
case CC_OP_ADCB: case CC_OP_ADCB:
return compute_all_adcb(env); return compute_all_adcb(dst, src1);
case CC_OP_ADCW: case CC_OP_ADCW:
return compute_all_adcw(env); return compute_all_adcw(dst, src1);
case CC_OP_ADCL: case CC_OP_ADCL:
return compute_all_adcl(env); return compute_all_adcl(dst, src1);
case CC_OP_SUBB: case CC_OP_SUBB:
return compute_all_subb(env); return compute_all_subb(dst, src1);
case CC_OP_SUBW: case CC_OP_SUBW:
return compute_all_subw(env); return compute_all_subw(dst, src1);
case CC_OP_SUBL: case CC_OP_SUBL:
return compute_all_subl(env); return compute_all_subl(dst, src1);
case CC_OP_SBBB: case CC_OP_SBBB:
return compute_all_sbbb(env); return compute_all_sbbb(dst, src1);
case CC_OP_SBBW: case CC_OP_SBBW:
return compute_all_sbbw(env); return compute_all_sbbw(dst, src1);
case CC_OP_SBBL: case CC_OP_SBBL:
return compute_all_sbbl(env); return compute_all_sbbl(dst, src1);
case CC_OP_LOGICB: case CC_OP_LOGICB:
return compute_all_logicb(env); return compute_all_logicb(dst, src1);
case CC_OP_LOGICW: case CC_OP_LOGICW:
return compute_all_logicw(env); return compute_all_logicw(dst, src1);
case CC_OP_LOGICL: case CC_OP_LOGICL:
return compute_all_logicl(env); return compute_all_logicl(dst, src1);
case CC_OP_INCB: case CC_OP_INCB:
return compute_all_incb(env); return compute_all_incb(dst, src1);
case CC_OP_INCW: case CC_OP_INCW:
return compute_all_incw(env); return compute_all_incw(dst, src1);
case CC_OP_INCL: case CC_OP_INCL:
return compute_all_incl(env); return compute_all_incl(dst, src1);
case CC_OP_DECB: case CC_OP_DECB:
return compute_all_decb(env); return compute_all_decb(dst, src1);
case CC_OP_DECW: case CC_OP_DECW:
return compute_all_decw(env); return compute_all_decw(dst, src1);
case CC_OP_DECL: case CC_OP_DECL:
return compute_all_decl(env); return compute_all_decl(dst, src1);
case CC_OP_SHLB: case CC_OP_SHLB:
return compute_all_shlb(env); return compute_all_shlb(dst, src1);
case CC_OP_SHLW: case CC_OP_SHLW:
return compute_all_shlw(env); return compute_all_shlw(dst, src1);
case CC_OP_SHLL: case CC_OP_SHLL:
return compute_all_shll(env); return compute_all_shll(dst, src1);
case CC_OP_SARB: case CC_OP_SARB:
return compute_all_sarb(env); return compute_all_sarb(dst, src1);
case CC_OP_SARW: case CC_OP_SARW:
return compute_all_sarw(env); return compute_all_sarw(dst, src1);
case CC_OP_SARL: case CC_OP_SARL:
return compute_all_sarl(env); return compute_all_sarl(dst, src1);
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
case CC_OP_MULQ: case CC_OP_MULQ:
return compute_all_mulq(env); return compute_all_mulq(dst, src1);
case CC_OP_ADDQ: case CC_OP_ADDQ:
return compute_all_addq(env); return compute_all_addq(dst, src1);
case CC_OP_ADCQ: case CC_OP_ADCQ:
return compute_all_adcq(env); return compute_all_adcq(dst, src1);
case CC_OP_SUBQ: case CC_OP_SUBQ:
return compute_all_subq(env); return compute_all_subq(dst, src1);
case CC_OP_SBBQ: case CC_OP_SBBQ:
return compute_all_sbbq(env); return compute_all_sbbq(dst, src1);
case CC_OP_LOGICQ: case CC_OP_LOGICQ:
return compute_all_logicq(env); return compute_all_logicq(dst, src1);
case CC_OP_INCQ: case CC_OP_INCQ:
return compute_all_incq(env); return compute_all_incq(dst, src1);
case CC_OP_DECQ: case CC_OP_DECQ:
return compute_all_decq(env); return compute_all_decq(dst, src1);
case CC_OP_SHLQ: case CC_OP_SHLQ:
return compute_all_shlq(env); return compute_all_shlq(dst, src1);
case CC_OP_SARQ: case CC_OP_SARQ:
return compute_all_sarq(env); return compute_all_sarq(dst, src1);
#endif #endif
} }
} }
@ -205,113 +188,85 @@ uint32_t cpu_cc_compute_all(CPUX86State *env, int op)
uint32_t helper_cc_compute_c(CPUX86State *env, int op) uint32_t helper_cc_compute_c(CPUX86State *env, int op)
{ {
target_ulong dst = CC_DST, src1 = CC_SRC;
switch (op) { switch (op) {
default: /* should never happen */ default: /* should never happen */
case CC_OP_LOGICB:
case CC_OP_LOGICW:
case CC_OP_LOGICL:
case CC_OP_LOGICQ:
return 0; return 0;
case CC_OP_EFLAGS: case CC_OP_EFLAGS:
return compute_c_eflags(env); case CC_OP_SARB:
case CC_OP_SARW:
case CC_OP_MULB: case CC_OP_SARL:
return compute_c_mull(env); case CC_OP_SARQ:
case CC_OP_MULW: return src1 & 1;
return compute_c_mull(env);
case CC_OP_MULL:
return compute_c_mull(env);
case CC_OP_ADDB:
return compute_c_addb(env);
case CC_OP_ADDW:
return compute_c_addw(env);
case CC_OP_ADDL:
return compute_c_addl(env);
case CC_OP_ADCB:
return compute_c_adcb(env);
case CC_OP_ADCW:
return compute_c_adcw(env);
case CC_OP_ADCL:
return compute_c_adcl(env);
case CC_OP_SUBB:
return compute_c_subb(env);
case CC_OP_SUBW:
return compute_c_subw(env);
case CC_OP_SUBL:
return compute_c_subl(env);
case CC_OP_SBBB:
return compute_c_sbbb(env);
case CC_OP_SBBW:
return compute_c_sbbw(env);
case CC_OP_SBBL:
return compute_c_sbbl(env);
case CC_OP_LOGICB:
return compute_c_logicb();
case CC_OP_LOGICW:
return compute_c_logicw();
case CC_OP_LOGICL:
return compute_c_logicl();
case CC_OP_INCB: case CC_OP_INCB:
return compute_c_incl(env);
case CC_OP_INCW: case CC_OP_INCW:
return compute_c_incl(env);
case CC_OP_INCL: case CC_OP_INCL:
return compute_c_incl(env); case CC_OP_INCQ:
case CC_OP_DECB: case CC_OP_DECB:
return compute_c_incl(env);
case CC_OP_DECW: case CC_OP_DECW:
return compute_c_incl(env);
case CC_OP_DECL: case CC_OP_DECL:
return compute_c_incl(env); case CC_OP_DECQ:
return src1;
case CC_OP_MULB:
case CC_OP_MULW:
case CC_OP_MULL:
case CC_OP_MULQ:
return src1 != 0;
case CC_OP_ADDB:
return compute_c_addb(dst, src1);
case CC_OP_ADDW:
return compute_c_addw(dst, src1);
case CC_OP_ADDL:
return compute_c_addl(dst, src1);
case CC_OP_ADCB:
return compute_c_adcb(dst, src1);
case CC_OP_ADCW:
return compute_c_adcw(dst, src1);
case CC_OP_ADCL:
return compute_c_adcl(dst, src1);
case CC_OP_SUBB:
return compute_c_subb(dst, src1);
case CC_OP_SUBW:
return compute_c_subw(dst, src1);
case CC_OP_SUBL:
return compute_c_subl(dst, src1);
case CC_OP_SBBB:
return compute_c_sbbb(dst, src1);
case CC_OP_SBBW:
return compute_c_sbbw(dst, src1);
case CC_OP_SBBL:
return compute_c_sbbl(dst, src1);
case CC_OP_SHLB: case CC_OP_SHLB:
return compute_c_shlb(env); return compute_c_shlb(dst, src1);
case CC_OP_SHLW: case CC_OP_SHLW:
return compute_c_shlw(env); return compute_c_shlw(dst, src1);
case CC_OP_SHLL: case CC_OP_SHLL:
return compute_c_shll(env); return compute_c_shll(dst, src1);
case CC_OP_SARB:
return compute_c_sarl(env);
case CC_OP_SARW:
return compute_c_sarl(env);
case CC_OP_SARL:
return compute_c_sarl(env);
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
case CC_OP_MULQ:
return compute_c_mull(env);
case CC_OP_ADDQ: case CC_OP_ADDQ:
return compute_c_addq(env); return compute_c_addq(dst, src1);
case CC_OP_ADCQ: case CC_OP_ADCQ:
return compute_c_adcq(env); return compute_c_adcq(dst, src1);
case CC_OP_SUBQ: case CC_OP_SUBQ:
return compute_c_subq(env); return compute_c_subq(dst, src1);
case CC_OP_SBBQ: case CC_OP_SBBQ:
return compute_c_sbbq(env); return compute_c_sbbq(dst, src1);
case CC_OP_LOGICQ:
return compute_c_logicq();
case CC_OP_INCQ:
return compute_c_incl(env);
case CC_OP_DECQ:
return compute_c_incl(env);
case CC_OP_SHLQ: case CC_OP_SHLQ:
return compute_c_shlq(env); return compute_c_shlq(dst, src1);
case CC_OP_SARQ:
return compute_c_sarl(env);
#endif #endif
} }
} }

237
target-i386/cc_helper_template.h
View File

@ -18,255 +18,198 @@
*/ */
#define DATA_BITS (1 << (3 + SHIFT)) #define DATA_BITS (1 << (3 + SHIFT))
#define SIGN_MASK (((target_ulong)1) << (DATA_BITS - 1))
#if DATA_BITS == 8 #if DATA_BITS == 8
#define SUFFIX b #define SUFFIX b
#define DATA_TYPE uint8_t #define DATA_TYPE uint8_t
#define DATA_MASK 0xff
#elif DATA_BITS == 16 #elif DATA_BITS == 16
#define SUFFIX w #define SUFFIX w
#define DATA_TYPE uint16_t #define DATA_TYPE uint16_t
#define DATA_MASK 0xffff
#elif DATA_BITS == 32 #elif DATA_BITS == 32
#define SUFFIX l #define SUFFIX l
#define DATA_TYPE uint32_t #define DATA_TYPE uint32_t
#define DATA_MASK 0xffffffff
#elif DATA_BITS == 64 #elif DATA_BITS == 64
#define SUFFIX q #define SUFFIX q
#define DATA_TYPE uint64_t #define DATA_TYPE uint64_t
#define DATA_MASK 0xffffffffffffffffULL
#else #else
#error unhandled operand size #error unhandled operand size
#endif #endif
#define SIGN_MASK (((DATA_TYPE)1) << (DATA_BITS - 1))
/* dynamic flags computation */ /* dynamic flags computation */
static int glue(compute_all_add, SUFFIX)(CPUX86State *env) static int glue(compute_all_add, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
target_long src1, src2; DATA_TYPE src2 = dst - src1;
src1 = CC_SRC; cf = dst < src1;
src2 = CC_DST - CC_SRC; pf = parity_table[(uint8_t)dst];
cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1; af = (dst ^ src1 ^ src2) & CC_A;
pf = parity_table[(uint8_t)CC_DST]; zf = (dst == 0) * CC_Z;
af = (CC_DST ^ src1 ^ src2) & 0x10; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
zf = ((DATA_TYPE)CC_DST == 0) << 6; of = lshift((src1 ^ src2 ^ -1) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
static int glue(compute_c_add, SUFFIX)(CPUX86State *env) static int glue(compute_c_add, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{ {
int cf; return dst < src1;
target_long src1;
src1 = CC_SRC;
cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
return cf;
} }
static int glue(compute_all_adc, SUFFIX)(CPUX86State *env) static int glue(compute_all_adc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
target_long src1, src2; DATA_TYPE src2 = dst - src1 - 1;
src1 = CC_SRC; cf = dst <= src1;
src2 = CC_DST - CC_SRC - 1; pf = parity_table[(uint8_t)dst];
cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1; af = (dst ^ src1 ^ src2) & 0x10;
pf = parity_table[(uint8_t)CC_DST]; zf = (dst == 0) << 6;
af = (CC_DST ^ src1 ^ src2) & 0x10; sf = lshift(dst, 8 - DATA_BITS) & 0x80;
zf = ((DATA_TYPE)CC_DST == 0) << 6; of = lshift((src1 ^ src2 ^ -1) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
static int glue(compute_c_adc, SUFFIX)(CPUX86State *env) static int glue(compute_c_adc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{ {
int cf; return dst <= src1;
target_long src1;
src1 = CC_SRC;
cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
return cf;
} }
static int glue(compute_all_sub, SUFFIX)(CPUX86State *env) static int glue(compute_all_sub, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
target_long src1, src2; DATA_TYPE src1 = dst + src2;
src1 = CC_DST + CC_SRC; cf = src1 < src2;
src2 = CC_SRC; pf = parity_table[(uint8_t)dst];
cf = (DATA_TYPE)src1 < (DATA_TYPE)src2; af = (dst ^ src1 ^ src2) & CC_A;
pf = parity_table[(uint8_t)CC_DST]; zf = (dst == 0) * CC_Z;
af = (CC_DST ^ src1 ^ src2) & 0x10; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
zf = ((DATA_TYPE)CC_DST == 0) << 6; of = lshift((src1 ^ src2) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
static int glue(compute_c_sub, SUFFIX)(CPUX86State *env) static int glue(compute_c_sub, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2)
{ {
int cf; DATA_TYPE src1 = dst + src2;
target_long src1, src2;
src1 = CC_DST + CC_SRC; return src1 < src2;
src2 = CC_SRC;
cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
return cf;
} }
static int glue(compute_all_sbb, SUFFIX)(CPUX86State *env) static int glue(compute_all_sbb, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
target_long src1, src2; DATA_TYPE src1 = dst + src2 + 1;
src1 = CC_DST + CC_SRC + 1; cf = src1 <= src2;
src2 = CC_SRC; pf = parity_table[(uint8_t)dst];
cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2; af = (dst ^ src1 ^ src2) & 0x10;
pf = parity_table[(uint8_t)CC_DST]; zf = (dst == 0) << 6;
af = (CC_DST ^ src1 ^ src2) & 0x10; sf = lshift(dst, 8 - DATA_BITS) & 0x80;
zf = ((DATA_TYPE)CC_DST == 0) << 6; of = lshift((src1 ^ src2) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
static int glue(compute_c_sbb, SUFFIX)(CPUX86State *env) static int glue(compute_c_sbb, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2)
{ {
int cf; DATA_TYPE src1 = dst + src2 + 1;
target_long src1, src2;
src1 = CC_DST + CC_SRC + 1; return src1 <= src2;
src2 = CC_SRC;
cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
return cf;
} }
static int glue(compute_all_logic, SUFFIX)(CPUX86State *env) static int glue(compute_all_logic, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
cf = 0; cf = 0;
pf = parity_table[(uint8_t)CC_DST]; pf = parity_table[(uint8_t)dst];
af = 0; af = 0;
zf = ((DATA_TYPE)CC_DST == 0) << 6; zf = (dst == 0) * CC_Z;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
of = 0; of = 0;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
static int glue(compute_c_logic, SUFFIX)(void) static int glue(compute_all_inc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{
return 0;
}
static int glue(compute_all_inc, SUFFIX)(CPUX86State *env)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
target_long src1, src2; DATA_TYPE src2;
src1 = CC_DST - 1; cf = src1;
src1 = dst - 1;
src2 = 1; src2 = 1;
cf = CC_SRC; pf = parity_table[(uint8_t)dst];
pf = parity_table[(uint8_t)CC_DST]; af = (dst ^ src1 ^ src2) & CC_A;
af = (CC_DST ^ src1 ^ src2) & 0x10; zf = (dst == 0) * CC_Z;
zf = ((DATA_TYPE)CC_DST == 0) << 6; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; of = (dst == SIGN_MASK) * CC_O;
of = ((CC_DST & DATA_MASK) == SIGN_MASK) << 11;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
#if DATA_BITS == 32 static int glue(compute_all_dec, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
static int glue(compute_c_inc, SUFFIX)(CPUX86State *env)
{
return CC_SRC;
}
#endif
static int glue(compute_all_dec, SUFFIX)(CPUX86State *env)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
target_long src1, src2; DATA_TYPE src2;
src1 = CC_DST + 1; cf = src1;
src1 = dst + 1;
src2 = 1; src2 = 1;
cf = CC_SRC; pf = parity_table[(uint8_t)dst];
pf = parity_table[(uint8_t)CC_DST]; af = (dst ^ src1 ^ src2) & CC_A;
af = (CC_DST ^ src1 ^ src2) & 0x10; zf = (dst == 0) * CC_Z;
zf = ((DATA_TYPE)CC_DST == 0) << 6; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; of = (dst == SIGN_MASK - 1) * CC_O;
of = ((CC_DST & DATA_MASK) == ((target_ulong)SIGN_MASK - 1)) << 11;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
static int glue(compute_all_shl, SUFFIX)(CPUX86State *env) static int glue(compute_all_shl, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
cf = (CC_SRC >> (DATA_BITS - 1)) & CC_C; cf = (src1 >> (DATA_BITS - 1)) & CC_C;
pf = parity_table[(uint8_t)CC_DST]; pf = parity_table[(uint8_t)dst];
af = 0; /* undefined */ af = 0; /* undefined */
zf = ((DATA_TYPE)CC_DST == 0) << 6; zf = (dst == 0) * CC_Z;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
/* of is defined if shift count == 1 */ /* of is defined iff shift count == 1 */
of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O; of = lshift(src1 ^ dst, 12 - DATA_BITS) & CC_O;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
static int glue(compute_c_shl, SUFFIX)(CPUX86State *env) static int glue(compute_c_shl, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
{ {
return (CC_SRC >> (DATA_BITS - 1)) & CC_C; return (src1 >> (DATA_BITS - 1)) & CC_C;
} }
#if DATA_BITS == 32 static int glue(compute_all_sar, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
static int glue(compute_c_sar, SUFFIX)(CPUX86State *env)
{
return CC_SRC & 1;
}
#endif
static int glue(compute_all_sar, SUFFIX)(CPUX86State *env)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
cf = CC_SRC & 1; cf = src1 & 1;
pf = parity_table[(uint8_t)CC_DST]; pf = parity_table[(uint8_t)dst];
af = 0; /* undefined */ af = 0; /* undefined */
zf = ((DATA_TYPE)CC_DST == 0) << 6; zf = (dst == 0) * CC_Z;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
/* of is defined if shift count == 1 */ /* of is defined iff shift count == 1 */
of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O; of = lshift(src1 ^ dst, 12 - DATA_BITS) & CC_O;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }
#if DATA_BITS == 32
static int glue(compute_c_mul, SUFFIX)(CPUX86State *env)
{
int cf;
cf = (CC_SRC != 0);
return cf;
}
#endif
/* NOTE: we compute the flags like the P4. On olders CPUs, only OF and /* NOTE: we compute the flags like the P4. On olders CPUs, only OF and
CF are modified and it is slower to do that. */ CF are modified and it is slower to do that. Note as well that we
static int glue(compute_all_mul, SUFFIX)(CPUX86State *env) don't truncate SRC1 for computing carry to DATA_TYPE. */
static int glue(compute_all_mul, SUFFIX)(DATA_TYPE dst, target_long src1)
{ {
int cf, pf, af, zf, sf, of; int cf, pf, af, zf, sf, of;
cf = (CC_SRC != 0); cf = (src1 != 0);
pf = parity_table[(uint8_t)CC_DST]; pf = parity_table[(uint8_t)dst];
af = 0; /* undefined */ af = 0; /* undefined */
zf = ((DATA_TYPE)CC_DST == 0) << 6; zf = (dst == 0) * CC_Z;
sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; sf = lshift(dst, 8 - DATA_BITS) & CC_S;
of = cf << 11; of = cf * CC_O;
return cf | pf | af | zf | sf | of; return cf | pf | af | zf | sf | of;
} }