[qemu.git] / target-i386 / ops_template.h

/*
 *  i386 micro operations (included several times to generate
 *  different operand sizes)
 * 
 *  Copyright (c) 2003 Fabrice Bellard
 *
 * 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
 * Lesser 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
 */
#define DATA_BITS (1 << (3 + SHIFT))
#define SHIFT_MASK (DATA_BITS - 1)
#define SIGN_MASK (1 << (DATA_BITS - 1))

#if DATA_BITS == 8
#define SUFFIX b
#define DATA_TYPE uint8_t
#define DATA_STYPE int8_t
#define DATA_MASK 0xff
#elif DATA_BITS == 16
#define SUFFIX w
#define DATA_TYPE uint16_t
#define DATA_STYPE int16_t
#define DATA_MASK 0xffff
#elif DATA_BITS == 32
#define SUFFIX l
#define DATA_TYPE uint32_t
#define DATA_STYPE int32_t
#define DATA_MASK 0xffffffff
#else
#error unhandled operand size
#endif

/* dynamic flags computation */

static int glue(compute_all_add, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    int src1, src2;
    src1 = CC_SRC;
    src2 = CC_DST - CC_SRC;
    cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
    pf = parity_table[(uint8_t)CC_DST];
    af = (CC_DST ^ src1 ^ src2) & 0x10;
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    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;
}

static int glue(compute_c_add, SUFFIX)(void)
{
    int src1, cf;
    src1 = CC_SRC;
    cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
    return cf;
}

static int glue(compute_all_adc, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    int src1, src2;
    src1 = CC_SRC;
    src2 = CC_DST - CC_SRC - 1;
    cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
    pf = parity_table[(uint8_t)CC_DST];
    af = (CC_DST ^ src1 ^ src2) & 0x10;
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    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;
}

static int glue(compute_c_adc, SUFFIX)(void)
{
    int src1, cf;
    src1 = CC_SRC;
    cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
    return cf;
}

static int glue(compute_all_sub, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;
    cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
    pf = parity_table[(uint8_t)CC_DST];
    af = (CC_DST ^ src1 ^ src2) & 0x10;
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    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;
}

static int glue(compute_c_sub, SUFFIX)(void)
{
    int src1, src2, cf;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;
    cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
    return cf;
}

static int glue(compute_all_sbb, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    int src1, src2;
    src1 = CC_DST + CC_SRC + 1;
    src2 = CC_SRC;
    cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
    pf = parity_table[(uint8_t)CC_DST];
    af = (CC_DST ^ src1 ^ src2) & 0x10;
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    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;
}

static int glue(compute_c_sbb, SUFFIX)(void)
{
    int src1, src2, cf;
    src1 = CC_DST + CC_SRC + 1;
    src2 = CC_SRC;
    cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
    return cf;
}

static int glue(compute_all_logic, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    cf = 0;
    pf = parity_table[(uint8_t)CC_DST];
    af = 0;
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
    of = 0;
    return cf | pf | af | zf | sf | of;
}

static int glue(compute_c_logic, SUFFIX)(void)
{
    return 0;
}

static int glue(compute_all_inc, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    int src1, src2;
    src1 = CC_DST - 1;
    src2 = 1;
    cf = CC_SRC;
    pf = parity_table[(uint8_t)CC_DST];
    af = (CC_DST ^ src1 ^ src2) & 0x10;
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
    of = ((CC_DST & DATA_MASK) == SIGN_MASK) << 11;
    return cf | pf | af | zf | sf | of;
}

#if DATA_BITS == 32
static int glue(compute_c_inc, SUFFIX)(void)
{
    return CC_SRC;
}
#endif

static int glue(compute_all_dec, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    int src1, src2;
    src1 = CC_DST + 1;
    src2 = 1;
    cf = CC_SRC;
    pf = parity_table[(uint8_t)CC_DST];
    af = (CC_DST ^ src1 ^ src2) & 0x10;
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
    of = ((CC_DST & DATA_MASK) == ((uint32_t)SIGN_MASK - 1)) << 11;
    return cf | pf | af | zf | sf | of;
}

static int glue(compute_all_shl, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    cf = (CC_SRC >> (DATA_BITS - 1)) & CC_C;
    pf = parity_table[(uint8_t)CC_DST];
    af = 0; /* undefined */
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
    /* of is defined if shift count == 1 */
    of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
    return cf | pf | af | zf | sf | of;
}

static int glue(compute_c_shl, SUFFIX)(void)
{
    return (CC_SRC >> (DATA_BITS - 1)) & CC_C;
}

#if DATA_BITS == 32
static int glue(compute_c_sar, SUFFIX)(void)
{
    return CC_SRC & 1;
}
#endif

static int glue(compute_all_sar, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    cf = CC_SRC & 1;
    pf = parity_table[(uint8_t)CC_DST];
    af = 0; /* undefined */
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
    /* of is defined if shift count == 1 */
    of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O; 
    return cf | pf | af | zf | sf | of;
}

#if DATA_BITS == 32
static int glue(compute_c_mul, SUFFIX)(void)
{
    int cf;
    cf = (CC_SRC != 0);
    return cf;
}
#endif

/* NOTE: we compute the flags like the P4. On olders CPUs, only OF and
   CF are modified and it is slower to do that. */
static int glue(compute_all_mul, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    cf = (CC_SRC != 0);
    pf = parity_table[(uint8_t)CC_DST];
    af = 0; /* undefined */
    zf = ((DATA_TYPE)CC_DST == 0) << 6;
    sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
    of = cf << 11;
    return cf | pf | af | zf | sf | of;
}

/* various optimized jumps cases */

void OPPROTO glue(op_jb_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    if ((DATA_TYPE)src1 < (DATA_TYPE)src2)
        JUMP_TB(glue(op_jb_sub, SUFFIX), PARAM1, 0, PARAM2);
    else
        JUMP_TB(glue(op_jb_sub, SUFFIX), PARAM1, 1, PARAM3);
    FORCE_RET();
}

void OPPROTO glue(op_jz_sub, SUFFIX)(void)
{
    if ((DATA_TYPE)CC_DST == 0)
        JUMP_TB(glue(op_jz_sub, SUFFIX), PARAM1, 0, PARAM2);
    else
        JUMP_TB(glue(op_jz_sub, SUFFIX), PARAM1, 1, PARAM3);
    FORCE_RET();
}

void OPPROTO glue(op_jbe_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    if ((DATA_TYPE)src1 <= (DATA_TYPE)src2)
        JUMP_TB(glue(op_jbe_sub, SUFFIX), PARAM1, 0, PARAM2);
    else
        JUMP_TB(glue(op_jbe_sub, SUFFIX), PARAM1, 1, PARAM3);
    FORCE_RET();
}

void OPPROTO glue(op_js_sub, SUFFIX)(void)
{
    if (CC_DST & SIGN_MASK)
        JUMP_TB(glue(op_js_sub, SUFFIX), PARAM1, 0, PARAM2);
    else
        JUMP_TB(glue(op_js_sub, SUFFIX), PARAM1, 1, PARAM3);
    FORCE_RET();
}

void OPPROTO glue(op_jl_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    if ((DATA_STYPE)src1 < (DATA_STYPE)src2)
        JUMP_TB(glue(op_jl_sub, SUFFIX), PARAM1, 0, PARAM2);
    else
        JUMP_TB(glue(op_jl_sub, SUFFIX), PARAM1, 1, PARAM3);
    FORCE_RET();
}

void OPPROTO glue(op_jle_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    if ((DATA_STYPE)src1 <= (DATA_STYPE)src2)
        JUMP_TB(glue(op_jle_sub, SUFFIX), PARAM1, 0, PARAM2);
    else
        JUMP_TB(glue(op_jle_sub, SUFFIX), PARAM1, 1, PARAM3);
    FORCE_RET();
}

/* oldies */

#if DATA_BITS >= 16

void OPPROTO glue(op_loopnz, SUFFIX)(void)
{
    unsigned int tmp;
    int eflags;
    eflags = cc_table[CC_OP].compute_all();
    tmp = (ECX - 1) & DATA_MASK;
    ECX = (ECX & ~DATA_MASK) | tmp;
    if (tmp != 0 && !(eflags & CC_Z))
        EIP = PARAM1;
    else
        EIP = PARAM2;
    FORCE_RET();
}

void OPPROTO glue(op_loopz, SUFFIX)(void)
{
    unsigned int tmp;
    int eflags;
    eflags = cc_table[CC_OP].compute_all();
    tmp = (ECX - 1) & DATA_MASK;
    ECX = (ECX & ~DATA_MASK) | tmp;
    if (tmp != 0 && (eflags & CC_Z))
        EIP = PARAM1;
    else
        EIP = PARAM2;
    FORCE_RET();
}

void OPPROTO glue(op_loop, SUFFIX)(void)
{
    unsigned int tmp;
    tmp = (ECX - 1) & DATA_MASK;
    ECX = (ECX & ~DATA_MASK) | tmp;
    if (tmp != 0)
        EIP = PARAM1;
    else
        EIP = PARAM2;
    FORCE_RET();
}

void OPPROTO glue(op_jecxz, SUFFIX)(void)
{
    if ((DATA_TYPE)ECX == 0)
        EIP = PARAM1;
    else
        EIP = PARAM2;
    FORCE_RET();
}

#endif

/* various optimized set cases */

void OPPROTO glue(op_setb_T0_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    T0 = ((DATA_TYPE)src1 < (DATA_TYPE)src2);
}

void OPPROTO glue(op_setz_T0_sub, SUFFIX)(void)
{
    T0 = ((DATA_TYPE)CC_DST == 0);
}

void OPPROTO glue(op_setbe_T0_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    T0 = ((DATA_TYPE)src1 <= (DATA_TYPE)src2);
}

void OPPROTO glue(op_sets_T0_sub, SUFFIX)(void)
{
    T0 = lshift(CC_DST, -(DATA_BITS - 1)) & 1;
}

void OPPROTO glue(op_setl_T0_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    T0 = ((DATA_STYPE)src1 < (DATA_STYPE)src2);
}

void OPPROTO glue(op_setle_T0_sub, SUFFIX)(void)
{
    int src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    T0 = ((DATA_STYPE)src1 <= (DATA_STYPE)src2);
}

/* shifts */

void OPPROTO glue(glue(op_shl, SUFFIX), _T0_T1)(void)
{
    int count;
    count = T1 & 0x1f;
    T0 = T0 << count;
    FORCE_RET();
}

void OPPROTO glue(glue(op_shr, SUFFIX), _T0_T1)(void)
{
    int count;
    count = T1 & 0x1f;
    T0 &= DATA_MASK;
    T0 = T0 >> count;
    FORCE_RET();
}

void OPPROTO glue(glue(op_sar, SUFFIX), _T0_T1)(void)
{
    int count, src;
    count = T1 & 0x1f;
    src = (DATA_STYPE)T0;
    T0 = src >> count;
    FORCE_RET();
}

#undef MEM_WRITE
#include "ops_template_mem.h"

#define MEM_WRITE 0
#include "ops_template_mem.h"

#if !defined(CONFIG_USER_ONLY)
#define MEM_WRITE 1
#include "ops_template_mem.h"

#define MEM_WRITE 2
#include "ops_template_mem.h"
#endif

/* bit operations */
#if DATA_BITS >= 16

void OPPROTO glue(glue(op_bt, SUFFIX), _T0_T1_cc)(void)
{
    int count;
    count = T1 & SHIFT_MASK;
    CC_SRC = T0 >> count;
}

void OPPROTO glue(glue(op_bts, SUFFIX), _T0_T1_cc)(void)
{
    int count;
    count = T1 & SHIFT_MASK;
    T1 = T0 >> count;
    T0 |= (1 << count);
}

void OPPROTO glue(glue(op_btr, SUFFIX), _T0_T1_cc)(void)
{
    int count;
    count = T1 & SHIFT_MASK;
    T1 = T0 >> count;
    T0 &= ~(1 << count);
}

void OPPROTO glue(glue(op_btc, SUFFIX), _T0_T1_cc)(void)
{
    int count;
    count = T1 & SHIFT_MASK;
    T1 = T0 >> count;
    T0 ^= (1 << count);
}

void OPPROTO glue(glue(op_bsf, SUFFIX), _T0_cc)(void)
{
    int res, count;
    res = T0 & DATA_MASK;
    if (res != 0) {
        count = 0;
        while ((res & 1) == 0) {
            count++;
            res >>= 1;
        }
        T1 = count;
        CC_DST = 1; /* ZF = 0 */
    } else {
        CC_DST = 0; /* ZF = 1 */
    }
    FORCE_RET();
}

void OPPROTO glue(glue(op_bsr, SUFFIX), _T0_cc)(void)
{
    int res, count;
    res = T0 & DATA_MASK;
    if (res != 0) {
        count = DATA_BITS - 1;
        while ((res & SIGN_MASK) == 0) {
            count--;
            res <<= 1;
        }
        T1 = count;
        CC_DST = 1; /* ZF = 0 */
    } else {
        CC_DST = 0; /* ZF = 1 */
    }
    FORCE_RET();
}

#endif

#if DATA_BITS == 32
void OPPROTO op_update_bt_cc(void)
{
    CC_SRC = T1;
}
#endif

/* string operations */

void OPPROTO glue(op_movl_T0_Dshift, SUFFIX)(void)
{
    T0 = DF << SHIFT;
}

void OPPROTO glue(op_string_jz_sub, SUFFIX)(void)
{
    if ((DATA_TYPE)CC_DST == 0)
        JUMP_TB2(glue(op_string_jz_sub, SUFFIX), PARAM1, 3);
    FORCE_RET();
}

void OPPROTO glue(op_string_jnz_sub, SUFFIX)(void)
{
    if ((DATA_TYPE)CC_DST != 0)
        JUMP_TB2(glue(op_string_jnz_sub, SUFFIX), PARAM1, 3);
    FORCE_RET();
}

void OPPROTO glue(glue(op_string_jz_sub, SUFFIX), _im)(void)
{
    if ((DATA_TYPE)CC_DST == 0) {
        EIP = PARAM1;
        if (env->eflags & TF_MASK) {
            raise_exception(EXCP01_SSTP);
        }
        T0 = 0;
        EXIT_TB();
    }
    FORCE_RET();
}

void OPPROTO glue(glue(op_string_jnz_sub, SUFFIX), _im)(void)
{
    if ((DATA_TYPE)CC_DST != 0) {
        EIP = PARAM1;
        if (env->eflags & TF_MASK) {
            raise_exception(EXCP01_SSTP);
        }
        T0 = 0;
        EXIT_TB();
    }
    FORCE_RET();
}

#if DATA_BITS >= 16
void OPPROTO glue(op_jz_ecx, SUFFIX)(void)
{
    if ((DATA_TYPE)ECX == 0)
        JUMP_TB(glue(op_jz_ecx, SUFFIX), PARAM1, 1, PARAM2);
    FORCE_RET();
}

void OPPROTO glue(glue(op_jz_ecx, SUFFIX), _im)(void)
{
    if ((DATA_TYPE)ECX == 0) {
        EIP = PARAM1;
        if (env->eflags & TF_MASK) {
            raise_exception(EXCP01_SSTP);
        }
        T0 = 0;
        EXIT_TB();
    }
    FORCE_RET();
}
#endif

/* port I/O */

void OPPROTO glue(glue(op_out, SUFFIX), _T0_T1)(void)
{
    glue(cpu_out, SUFFIX)(env, T0, T1 & DATA_MASK);
}

void OPPROTO glue(glue(op_in, SUFFIX), _T0_T1)(void)
{
    T1 = glue(cpu_in, SUFFIX)(env, T0);
}

void OPPROTO glue(glue(op_in, SUFFIX), _DX_T0)(void)
{
    T0 = glue(cpu_in, SUFFIX)(env, EDX & 0xffff);
}

void OPPROTO glue(glue(op_out, SUFFIX), _DX_T0)(void)
{
    glue(cpu_out, SUFFIX)(env, EDX & 0xffff, T0);
}

void OPPROTO glue(glue(op_check_io, SUFFIX), _T0)(void)
{
    glue(glue(check_io, SUFFIX), _T0)();
}

void OPPROTO glue(glue(op_check_io, SUFFIX), _DX)(void)
{
    glue(glue(check_io, SUFFIX), _DX)();
}

#undef DATA_BITS
#undef SHIFT_MASK
#undef SIGN_MASK
#undef DATA_TYPE
#undef DATA_STYPE
#undef DATA_MASK
#undef SUFFIX
Commit	Line	Data
2c0262af FB	1	/*
	2	* i386 micro operations (included several times to generate
	3	* different operand sizes)
	4	*
	5	* Copyright (c) 2003 Fabrice Bellard
	6	*
	7	* This library is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2 of the License, or (at your option) any later version.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with this library; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21	#define DATA_BITS (1 << (3 + SHIFT))
	22	#define SHIFT_MASK (DATA_BITS - 1)
	23	#define SIGN_MASK (1 << (DATA_BITS - 1))
	24
	25	#if DATA_BITS == 8
	26	#define SUFFIX b
	27	#define DATA_TYPE uint8_t
	28	#define DATA_STYPE int8_t
	29	#define DATA_MASK 0xff
	30	#elif DATA_BITS == 16
	31	#define SUFFIX w
	32	#define DATA_TYPE uint16_t
	33	#define DATA_STYPE int16_t
	34	#define DATA_MASK 0xffff
	35	#elif DATA_BITS == 32
	36	#define SUFFIX l
	37	#define DATA_TYPE uint32_t
	38	#define DATA_STYPE int32_t
	39	#define DATA_MASK 0xffffffff
	40	#else
	41	#error unhandled operand size
	42	#endif
	43
	44	/* dynamic flags computation */
	45
	46	static int glue(compute_all_add, SUFFIX)(void)
	47	{
	48	int cf, pf, af, zf, sf, of;
	49	int src1, src2;
	50	src1 = CC_SRC;
	51	src2 = CC_DST - CC_SRC;
	52	cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
	53	pf = parity_table[(uint8_t)CC_DST];
	54	af = (CC_DST ^ src1 ^ src2) & 0x10;
	55	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	56	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	57	of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
	58	return cf \| pf \| af \| zf \| sf \| of;
	59	}
	60
	61	static int glue(compute_c_add, SUFFIX)(void)
	62	{
	63	int src1, cf;
	64	src1 = CC_SRC;
65	cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
66	return cf;
67	}
68
69	static int glue(compute_all_adc, SUFFIX)(void)
70	{
71	int cf, pf, af, zf, sf, of;
72	int src1, src2;
73	src1 = CC_SRC;
74	src2 = CC_DST - CC_SRC - 1;
75	cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
76	pf = parity_table[(uint8_t)CC_DST];
77	af = (CC_DST ^ src1 ^ src2) & 0x10;
78	zf = ((DATA_TYPE)CC_DST == 0) << 6;
79	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
80	of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
81	return cf \| pf \| af \| zf \| sf \| of;
82	}
83
84	static int glue(compute_c_adc, SUFFIX)(void)
85	{
86	int src1, cf;
87	src1 = CC_SRC;
88	cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
89	return cf;
90	}
91
92	static int glue(compute_all_sub, SUFFIX)(void)
93	{
94	int cf, pf, af, zf, sf, of;
95	int src1, src2;
96	src1 = CC_DST + CC_SRC;
97	src2 = CC_SRC;
98	cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
99	pf = parity_table[(uint8_t)CC_DST];
100	af = (CC_DST ^ src1 ^ src2) & 0x10;
101	zf = ((DATA_TYPE)CC_DST == 0) << 6;
102	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
103	of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
104	return cf \| pf \| af \| zf \| sf \| of;
105	}
106
107	static int glue(compute_c_sub, SUFFIX)(void)
108	{
109	int src1, src2, cf;
110	src1 = CC_DST + CC_SRC;
111	src2 = CC_SRC;
112	cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
113	return cf;
114	}
115
116	static int glue(compute_all_sbb, SUFFIX)(void)
117	{
118	int cf, pf, af, zf, sf, of;
119	int src1, src2;
120	src1 = CC_DST + CC_SRC + 1;
121	src2 = CC_SRC;
122	cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
123	pf = parity_table[(uint8_t)CC_DST];
124	af = (CC_DST ^ src1 ^ src2) & 0x10;
125	zf = ((DATA_TYPE)CC_DST == 0) << 6;
126	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
127	of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
128	return cf \| pf \| af \| zf \| sf \| of;
129	}
130
131	static int glue(compute_c_sbb, SUFFIX)(void)
132	{
133	int src1, src2, cf;
134	src1 = CC_DST + CC_SRC + 1;
135	src2 = CC_SRC;
136	cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
137	return cf;
138	}
139
140	static int glue(compute_all_logic, SUFFIX)(void)
141	{
142	int cf, pf, af, zf, sf, of;
143	cf = 0;
144	pf = parity_table[(uint8_t)CC_DST];
145	af = 0;
146	zf = ((DATA_TYPE)CC_DST == 0) << 6;
147	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
148	of = 0;
149	return cf \| pf \| af \| zf \| sf \| of;
150	}
151
152	static int glue(compute_c_logic, SUFFIX)(void)
153	{
154	return 0;
155	}
156
157	static int glue(compute_all_inc, SUFFIX)(void)
158	{
159	int cf, pf, af, zf, sf, of;
160	int src1, src2;
161	src1 = CC_DST - 1;
162	src2 = 1;
163	cf = CC_SRC;
164	pf = parity_table[(uint8_t)CC_DST];
165	af = (CC_DST ^ src1 ^ src2) & 0x10;
166	zf = ((DATA_TYPE)CC_DST == 0) << 6;
167	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
168	of = ((CC_DST & DATA_MASK) == SIGN_MASK) << 11;
169	return cf \| pf \| af \| zf \| sf \| of;
170	}
171
172	#if DATA_BITS == 32
173	static int glue(compute_c_inc, SUFFIX)(void)
174	{
175	return CC_SRC;
176	}
177	#endif
178
179	static int glue(compute_all_dec, SUFFIX)(void)
180	{
181	int cf, pf, af, zf, sf, of;
182	int src1, src2;
183	src1 = CC_DST + 1;
184	src2 = 1;
185	cf = CC_SRC;
186	pf = parity_table[(uint8_t)CC_DST];
187	af = (CC_DST ^ src1 ^ src2) & 0x10;
188	zf = ((DATA_TYPE)CC_DST == 0) << 6;
189	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
190	of = ((CC_DST & DATA_MASK) == ((uint32_t)SIGN_MASK - 1)) << 11;
191	return cf \| pf \| af \| zf \| sf \| of;
192	}
193
194	static int glue(compute_all_shl, SUFFIX)(void)
195	{
196	int cf, pf, af, zf, sf, of;
197	cf = (CC_SRC >> (DATA_BITS - 1)) & CC_C;
198	pf = parity_table[(uint8_t)CC_DST];
199	af = 0; /* undefined */
200	zf = ((DATA_TYPE)CC_DST == 0) << 6;
201	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
202	/* of is defined if shift count == 1 */
203	of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
204	return cf \| pf \| af \| zf \| sf \| of;
205	}
206
207	static int glue(compute_c_shl, SUFFIX)(void)
208	{
209	return (CC_SRC >> (DATA_BITS - 1)) & CC_C;
210	}
211
212	#if DATA_BITS == 32
213	static int glue(compute_c_sar, SUFFIX)(void)
214	{
215	return CC_SRC & 1;
216	}
217	#endif
218
219	static int glue(compute_all_sar, SUFFIX)(void)
220	{
221	int cf, pf, af, zf, sf, of;
222	cf = CC_SRC & 1;
223	pf = parity_table[(uint8_t)CC_DST];
224	af = 0; /* undefined */
225	zf = ((DATA_TYPE)CC_DST == 0) << 6;
226	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
227	/* of is defined if shift count == 1 */
228	of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
229	return cf \| pf \| af \| zf \| sf \| of;
230	}
231
d36cd60e FB	232	#if DATA_BITS == 32
	233	static int glue(compute_c_mul, SUFFIX)(void)
	234	{
	235	int cf;
	236	cf = (CC_SRC != 0);
	237	return cf;
	238	}
	239	#endif
	240
	241	/* NOTE: we compute the flags like the P4. On olders CPUs, only OF and
	242	CF are modified and it is slower to do that. */
	243	static int glue(compute_all_mul, SUFFIX)(void)
	244	{
	245	int cf, pf, af, zf, sf, of;
	246	cf = (CC_SRC != 0);
	247	pf = parity_table[(uint8_t)CC_DST];
	248	af = 0; /* undefined */
	249	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	250	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	251	of = cf << 11;
	252	return cf \| pf \| af \| zf \| sf \| of;
	253	}
	254
2c0262af FB	255	/* various optimized jumps cases */
	256
	257	void OPPROTO glue(op_jb_sub, SUFFIX)(void)
	258	{
	259	int src1, src2;
	260	src1 = CC_DST + CC_SRC;
	261	src2 = CC_SRC;
	262
	263	if ((DATA_TYPE)src1 < (DATA_TYPE)src2)
	264	JUMP_TB(glue(op_jb_sub, SUFFIX), PARAM1, 0, PARAM2);
	265	else
	266	JUMP_TB(glue(op_jb_sub, SUFFIX), PARAM1, 1, PARAM3);
	267	FORCE_RET();
	268	}
	269
	270	void OPPROTO glue(op_jz_sub, SUFFIX)(void)
	271	{
	272	if ((DATA_TYPE)CC_DST == 0)
	273	JUMP_TB(glue(op_jz_sub, SUFFIX), PARAM1, 0, PARAM2);
	274	else
	275	JUMP_TB(glue(op_jz_sub, SUFFIX), PARAM1, 1, PARAM3);
	276	FORCE_RET();
	277	}
	278
	279	void OPPROTO glue(op_jbe_sub, SUFFIX)(void)
	280	{
	281	int src1, src2;
	282	src1 = CC_DST + CC_SRC;
	283	src2 = CC_SRC;
	284
	285	if ((DATA_TYPE)src1 <= (DATA_TYPE)src2)
	286	JUMP_TB(glue(op_jbe_sub, SUFFIX), PARAM1, 0, PARAM2);
	287	else
	288	JUMP_TB(glue(op_jbe_sub, SUFFIX), PARAM1, 1, PARAM3);
	289	FORCE_RET();
	290	}
	291
	292	void OPPROTO glue(op_js_sub, SUFFIX)(void)
	293	{
	294	if (CC_DST & SIGN_MASK)
	295	JUMP_TB(glue(op_js_sub, SUFFIX), PARAM1, 0, PARAM2);
	296	else
	297	JUMP_TB(glue(op_js_sub, SUFFIX), PARAM1, 1, PARAM3);
	298	FORCE_RET();
	299	}
	300
	301	void OPPROTO glue(op_jl_sub, SUFFIX)(void)
	302	{
	303	int src1, src2;
	304	src1 = CC_DST + CC_SRC;
	305	src2 = CC_SRC;
	306
	307	if ((DATA_STYPE)src1 < (DATA_STYPE)src2)
	308	JUMP_TB(glue(op_jl_sub, SUFFIX), PARAM1, 0, PARAM2);
	309	else
	310	JUMP_TB(glue(op_jl_sub, SUFFIX), PARAM1, 1, PARAM3);
	311	FORCE_RET();
	312	}
	313
	314	void OPPROTO glue(op_jle_sub, SUFFIX)(void)
	315	{
	316	int src1, src2;
	317	src1 = CC_DST + CC_SRC;
	318	src2 = CC_SRC;
319
320	if ((DATA_STYPE)src1 <= (DATA_STYPE)src2)
321	JUMP_TB(glue(op_jle_sub, SUFFIX), PARAM1, 0, PARAM2);
322	else
323	JUMP_TB(glue(op_jle_sub, SUFFIX), PARAM1, 1, PARAM3);
324	FORCE_RET();
325	}
326
327	/* oldies */
328
329	#if DATA_BITS >= 16
330
331	void OPPROTO glue(op_loopnz, SUFFIX)(void)
332	{
333	unsigned int tmp;
334	int eflags;
335	eflags = cc_table[CC_OP].compute_all();
336	tmp = (ECX - 1) & DATA_MASK;
337	ECX = (ECX & ~DATA_MASK) \| tmp;
338	if (tmp != 0 && !(eflags & CC_Z))
339	EIP = PARAM1;
340	else
341	EIP = PARAM2;
342	FORCE_RET();
343	}
344
345	void OPPROTO glue(op_loopz, SUFFIX)(void)
346	{
347	unsigned int tmp;
348	int eflags;
349	eflags = cc_table[CC_OP].compute_all();
350	tmp = (ECX - 1) & DATA_MASK;
351	ECX = (ECX & ~DATA_MASK) \| tmp;
352	if (tmp != 0 && (eflags & CC_Z))
353	EIP = PARAM1;
354	else
355	EIP = PARAM2;
356	FORCE_RET();
357	}
358
359	void OPPROTO glue(op_loop, SUFFIX)(void)
360	{
361	unsigned int tmp;
362	tmp = (ECX - 1) & DATA_MASK;
363	ECX = (ECX & ~DATA_MASK) \| tmp;
364	if (tmp != 0)
365	EIP = PARAM1;
366	else
367	EIP = PARAM2;
368	FORCE_RET();
369	}
370
371	void OPPROTO glue(op_jecxz, SUFFIX)(void)
372	{
373	if ((DATA_TYPE)ECX == 0)
374	EIP = PARAM1;
375	else
376	EIP = PARAM2;
377	FORCE_RET();
378	}
379
380	#endif
381
382	/* various optimized set cases */
383
384	void OPPROTO glue(op_setb_T0_sub, SUFFIX)(void)
385	{
386	int src1, src2;
387	src1 = CC_DST + CC_SRC;
388	src2 = CC_SRC;
389
390	T0 = ((DATA_TYPE)src1 < (DATA_TYPE)src2);
391	}
392
393	void OPPROTO glue(op_setz_T0_sub, SUFFIX)(void)
394	{
395	T0 = ((DATA_TYPE)CC_DST == 0);
396	}
397
398	void OPPROTO glue(op_setbe_T0_sub, SUFFIX)(void)
399	{
400	int src1, src2;
401	src1 = CC_DST + CC_SRC;
402	src2 = CC_SRC;
403
404	T0 = ((DATA_TYPE)src1 <= (DATA_TYPE)src2);
405	}
406
407	void OPPROTO glue(op_sets_T0_sub, SUFFIX)(void)
408	{
409	T0 = lshift(CC_DST, -(DATA_BITS - 1)) & 1;
410	}
411
412	void OPPROTO glue(op_setl_T0_sub, SUFFIX)(void)
413	{
414	int src1, src2;
415	src1 = CC_DST + CC_SRC;
416	src2 = CC_SRC;
417
418	T0 = ((DATA_STYPE)src1 < (DATA_STYPE)src2);
419	}
420
421	void OPPROTO glue(op_setle_T0_sub, SUFFIX)(void)
422	{
423	int src1, src2;
424	src1 = CC_DST + CC_SRC;
425	src2 = CC_SRC;
426
427	T0 = ((DATA_STYPE)src1 <= (DATA_STYPE)src2);
428	}
429
430	/* shifts */
431
432	void OPPROTO glue(glue(op_shl, SUFFIX), _T0_T1)(void)
433	{
434	int count;
435	count = T1 & 0x1f;
436	T0 = T0 << count;
437	FORCE_RET();
438	}
439
440	void OPPROTO glue(glue(op_shr, SUFFIX), _T0_T1)(void)
441	{
442	int count;
443	count = T1 & 0x1f;
444	T0 &= DATA_MASK;
445	T0 = T0 >> count;
446	FORCE_RET();
447	}
448
449	void OPPROTO glue(glue(op_sar, SUFFIX), _T0_T1)(void)
450	{
451	int count, src;
452	count = T1 & 0x1f;
453	src = (DATA_STYPE)T0;
454	T0 = src >> count;
455	FORCE_RET();
456	}
457
458	#undef MEM_WRITE
459	#include "ops_template_mem.h"
460
34e01bbf	461	#define MEM_WRITE 0
2c0262af FB	462	#include "ops_template_mem.h"
2c0262af FB	463
34e01bbf FB	464	#if !defined(CONFIG_USER_ONLY)
	465	#define MEM_WRITE 1
	466	#include "ops_template_mem.h"
	467
	468	#define MEM_WRITE 2
	469	#include "ops_template_mem.h"
	470	#endif
	471
2c0262af FB	472	/* bit operations */
	473	#if DATA_BITS >= 16
	474
	475	void OPPROTO glue(glue(op_bt, SUFFIX), _T0_T1_cc)(void)
	476	{
	477	int count;
	478	count = T1 & SHIFT_MASK;
	479	CC_SRC = T0 >> count;
	480	}
	481
	482	void OPPROTO glue(glue(op_bts, SUFFIX), _T0_T1_cc)(void)
	483	{
	484	int count;
	485	count = T1 & SHIFT_MASK;
	486	T1 = T0 >> count;
	487	T0 \|= (1 << count);
	488	}
	489
	490	void OPPROTO glue(glue(op_btr, SUFFIX), _T0_T1_cc)(void)
	491	{
	492	int count;
	493	count = T1 & SHIFT_MASK;
	494	T1 = T0 >> count;
	495	T0 &= ~(1 << count);
	496	}
	497
	498	void OPPROTO glue(glue(op_btc, SUFFIX), _T0_T1_cc)(void)
	499	{
	500	int count;
	501	count = T1 & SHIFT_MASK;
	502	T1 = T0 >> count;
	503	T0 ^= (1 << count);
	504	}
	505
	506	void OPPROTO glue(glue(op_bsf, SUFFIX), _T0_cc)(void)
	507	{
	508	int res, count;
	509	res = T0 & DATA_MASK;
	510	if (res != 0) {
	511	count = 0;
	512	while ((res & 1) == 0) {
	513	count++;
	514	res >>= 1;
	515	}
686f3f26	516	T1 = count;
debf7a7c	517	CC_DST = 1; /* ZF = 0 */
2c0262af FB	518	} else {
	519	CC_DST = 0; /* ZF = 1 */
	520	}
	521	FORCE_RET();
	522	}
	523
	524	void OPPROTO glue(glue(op_bsr, SUFFIX), _T0_cc)(void)
	525	{
	526	int res, count;
	527	res = T0 & DATA_MASK;
	528	if (res != 0) {
	529	count = DATA_BITS - 1;
	530	while ((res & SIGN_MASK) == 0) {
	531	count--;
	532	res <<= 1;
	533	}
686f3f26	534	T1 = count;
debf7a7c	535	CC_DST = 1; /* ZF = 0 */
2c0262af FB	536	} else {
	537	CC_DST = 0; /* ZF = 1 */
	538	}
	539	FORCE_RET();
	540	}
	541
	542	#endif
	543
	544	#if DATA_BITS == 32
	545	void OPPROTO op_update_bt_cc(void)
	546	{
	547	CC_SRC = T1;
	548	}
	549	#endif
	550
	551	/* string operations */
	552
	553	void OPPROTO glue(op_movl_T0_Dshift, SUFFIX)(void)
	554	{
	555	T0 = DF << SHIFT;
	556	}
	557
	558	void OPPROTO glue(op_string_jz_sub, SUFFIX)(void)
	559	{
	560	if ((DATA_TYPE)CC_DST == 0)
34e01bbf	561	JUMP_TB2(glue(op_string_jz_sub, SUFFIX), PARAM1, 3);
2c0262af FB	562	FORCE_RET();
	563	}
	564
	565	void OPPROTO glue(op_string_jnz_sub, SUFFIX)(void)
	566	{
	567	if ((DATA_TYPE)CC_DST != 0)
34e01bbf	568	JUMP_TB2(glue(op_string_jnz_sub, SUFFIX), PARAM1, 3);
2c0262af FB	569	FORCE_RET();
	570	}
	571
	572	void OPPROTO glue(glue(op_string_jz_sub, SUFFIX), _im)(void)
	573	{
	574	if ((DATA_TYPE)CC_DST == 0) {
	575	EIP = PARAM1;
	576	if (env->eflags & TF_MASK) {
	577	raise_exception(EXCP01_SSTP);
	578	}
	579	T0 = 0;
	580	EXIT_TB();
	581	}
	582	FORCE_RET();
	583	}
	584
	585	void OPPROTO glue(glue(op_string_jnz_sub, SUFFIX), _im)(void)
	586	{
	587	if ((DATA_TYPE)CC_DST != 0) {
	588	EIP = PARAM1;
	589	if (env->eflags & TF_MASK) {
	590	raise_exception(EXCP01_SSTP);
	591	}
	592	T0 = 0;
	593	EXIT_TB();
	594	}
	595	FORCE_RET();
	596	}
	597
	598	#if DATA_BITS >= 16
	599	void OPPROTO glue(op_jz_ecx, SUFFIX)(void)
	600	{
	601	if ((DATA_TYPE)ECX == 0)
	602	JUMP_TB(glue(op_jz_ecx, SUFFIX), PARAM1, 1, PARAM2);
	603	FORCE_RET();
	604	}
	605
	606	void OPPROTO glue(glue(op_jz_ecx, SUFFIX), _im)(void)
	607	{
	608	if ((DATA_TYPE)ECX == 0) {
	609	EIP = PARAM1;
	610	if (env->eflags & TF_MASK) {
	611	raise_exception(EXCP01_SSTP);
	612	}
	613	T0 = 0;
	614	EXIT_TB();
	615	}
	616	FORCE_RET();
	617	}
	618	#endif
	619
	620	/* port I/O */
	621
	622	void OPPROTO glue(glue(op_out, SUFFIX), _T0_T1)(void)
	623	{
4487d0ac	624	glue(cpu_out, SUFFIX)(env, T0, T1 & DATA_MASK);
2c0262af FB	625	}
	626
	627	void OPPROTO glue(glue(op_in, SUFFIX), _T0_T1)(void)
	628	{
4487d0ac	629	T1 = glue(cpu_in, SUFFIX)(env, T0);
2c0262af FB	630	}
	631
	632	void OPPROTO glue(glue(op_in, SUFFIX), _DX_T0)(void)
	633	{
4487d0ac	634	T0 = glue(cpu_in, SUFFIX)(env, EDX & 0xffff);
2c0262af FB	635	}
	636
	637	void OPPROTO glue(glue(op_out, SUFFIX), _DX_T0)(void)
	638	{
4487d0ac	639	glue(cpu_out, SUFFIX)(env, EDX & 0xffff, T0);
2c0262af FB	640	}
2c0262af FB	641
3e25f951 FB	642	void OPPROTO glue(glue(op_check_io, SUFFIX), _T0)(void)
	643	{
	644	glue(glue(check_io, SUFFIX), _T0)();
	645	}
	646
	647	void OPPROTO glue(glue(op_check_io, SUFFIX), _DX)(void)
	648	{
	649	glue(glue(check_io, SUFFIX), _DX)();
	650	}
	651
2c0262af FB	652	#undef DATA_BITS
	653	#undef SHIFT_MASK
	654	#undef SIGN_MASK
	655	#undef DATA_TYPE
	656	#undef DATA_STYPE
	657	#undef DATA_MASK
	658	#undef SUFFIX