[mirror_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 (((target_ulong)1) << (DATA_BITS - 1))
#if DATA_BITS <= 32
#define SHIFT1_MASK 0x1f
#else
#define SHIFT1_MASK 0x3f
#endif

#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
#elif DATA_BITS == 64
#define SUFFIX q
#define DATA_TYPE uint64_t
#define DATA_STYPE int64_t
#define DATA_MASK 0xffffffffffffffffULL
#else
#error unhandled operand size
#endif

/* dynamic flags computation */

static int glue(compute_all_add, SUFFIX)(void)
{
    int cf, pf, af, zf, sf, of;
    target_long 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 cf;
    target_long src1;
    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;
    target_long 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 cf;
    target_long src1;
    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;
    target_long 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 cf;
    target_long src1, src2;
    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;
    target_long 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 cf;
    target_long src1, src2;
    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;
    target_long 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;
    target_long 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) == ((target_ulong)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)
{
    target_long src1, src2;
    src1 = CC_DST + CC_SRC;
    src2 = CC_SRC;

    if ((DATA_TYPE)src1 < (DATA_TYPE)src2)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

void OPPROTO glue(op_jz_sub, SUFFIX)(void)
{
    if ((DATA_TYPE)CC_DST == 0)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

void OPPROTO glue(op_jnz_sub, SUFFIX)(void)
{
    if ((DATA_TYPE)CC_DST != 0)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

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

    if ((DATA_TYPE)src1 <= (DATA_TYPE)src2)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

void OPPROTO glue(op_js_sub, SUFFIX)(void)
{
    if (CC_DST & SIGN_MASK)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

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

    if ((DATA_STYPE)src1 < (DATA_STYPE)src2)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

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

    if ((DATA_STYPE)src1 <= (DATA_STYPE)src2)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

/* oldies */

#if DATA_BITS >= 16

void OPPROTO glue(op_loopnz, SUFFIX)(void)
{
    if ((DATA_TYPE)ECX != 0 && !(T0 & CC_Z))
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

void OPPROTO glue(op_loopz, SUFFIX)(void)
{
    if ((DATA_TYPE)ECX != 0 && (T0 & CC_Z))
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

void OPPROTO glue(op_jz_ecx, SUFFIX)(void)
{
    if ((DATA_TYPE)ECX == 0)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

void OPPROTO glue(op_jnz_ecx, SUFFIX)(void)
{
    if ((DATA_TYPE)ECX != 0)
        GOTO_LABEL_PARAM(1);
    FORCE_RET();
}

#endif

/* various optimized set cases */

void OPPROTO glue(op_setb_T0_sub, SUFFIX)(void)
{
    target_long 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)
{
    target_long 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)
{
    target_long 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)
{
    target_long 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 & SHIFT1_MASK;
    T0 = T0 << count;
    FORCE_RET();
}

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

void OPPROTO glue(glue(op_sar, SUFFIX), _T0_T1)(void)
{
    int count;
    target_long src;

    count = T1 & SHIFT1_MASK;
    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 |= (((target_long)1) << count);
}

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

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

void OPPROTO glue(glue(op_add_bit, SUFFIX), _A0_T1)(void)
{
    A0 += ((DATA_STYPE)T1 >> (3 + SHIFT)) << SHIFT;
}

void OPPROTO glue(glue(op_bsf, SUFFIX), _T0_cc)(void)
{
    int count;
    target_long res;
    
    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 count;
    target_long res;

    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;
}

/* port I/O */
#if DATA_BITS <= 32
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)();
}
#endif

#undef DATA_BITS
#undef SHIFT_MASK
#undef SHIFT1_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)
14ce26e7 FB	23	#define SIGN_MASK (((target_ulong)1) << (DATA_BITS - 1))
	24	#if DATA_BITS <= 32
	25	#define SHIFT1_MASK 0x1f
	26	#else
	27	#define SHIFT1_MASK 0x3f
	28	#endif
2c0262af FB	29
	30	#if DATA_BITS == 8
	31	#define SUFFIX b
	32	#define DATA_TYPE uint8_t
	33	#define DATA_STYPE int8_t
	34	#define DATA_MASK 0xff
	35	#elif DATA_BITS == 16
	36	#define SUFFIX w
	37	#define DATA_TYPE uint16_t
	38	#define DATA_STYPE int16_t
	39	#define DATA_MASK 0xffff
	40	#elif DATA_BITS == 32
	41	#define SUFFIX l
	42	#define DATA_TYPE uint32_t
	43	#define DATA_STYPE int32_t
	44	#define DATA_MASK 0xffffffff
14ce26e7 FB	45	#elif DATA_BITS == 64
	46	#define SUFFIX q
	47	#define DATA_TYPE uint64_t
	48	#define DATA_STYPE int64_t
977d5710	49	#define DATA_MASK 0xffffffffffffffffULL
2c0262af FB	50	#else
	51	#error unhandled operand size
	52	#endif
	53
	54	/* dynamic flags computation */
	55
	56	static int glue(compute_all_add, SUFFIX)(void)
	57	{
	58	int cf, pf, af, zf, sf, of;
14ce26e7	59	target_long src1, src2;
2c0262af FB	60	src1 = CC_SRC;
	61	src2 = CC_DST - CC_SRC;
	62	cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
	63	pf = parity_table[(uint8_t)CC_DST];
	64	af = (CC_DST ^ src1 ^ src2) & 0x10;
	65	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	66	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	67	of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
	68	return cf \| pf \| af \| zf \| sf \| of;
	69	}
	70
	71	static int glue(compute_c_add, SUFFIX)(void)
	72	{
14ce26e7 FB	73	int cf;
14ce26e7 FB	74	target_long src1;
2c0262af FB	75	src1 = CC_SRC;
	76	cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
	77	return cf;
	78	}
	79
	80	static int glue(compute_all_adc, SUFFIX)(void)
	81	{
	82	int cf, pf, af, zf, sf, of;
14ce26e7	83	target_long src1, src2;
2c0262af FB	84	src1 = CC_SRC;
	85	src2 = CC_DST - CC_SRC - 1;
	86	cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
	87	pf = parity_table[(uint8_t)CC_DST];
	88	af = (CC_DST ^ src1 ^ src2) & 0x10;
	89	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	90	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	91	of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
	92	return cf \| pf \| af \| zf \| sf \| of;
	93	}
	94
	95	static int glue(compute_c_adc, SUFFIX)(void)
	96	{
14ce26e7 FB	97	int cf;
14ce26e7 FB	98	target_long src1;
2c0262af FB	99	src1 = CC_SRC;
	100	cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
	101	return cf;
	102	}
	103
	104	static int glue(compute_all_sub, SUFFIX)(void)
	105	{
	106	int cf, pf, af, zf, sf, of;
14ce26e7	107	target_long src1, src2;
2c0262af FB	108	src1 = CC_DST + CC_SRC;
	109	src2 = CC_SRC;
	110	cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
	111	pf = parity_table[(uint8_t)CC_DST];
	112	af = (CC_DST ^ src1 ^ src2) & 0x10;
	113	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	114	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	115	of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
	116	return cf \| pf \| af \| zf \| sf \| of;
	117	}
	118
	119	static int glue(compute_c_sub, SUFFIX)(void)
	120	{
14ce26e7 FB	121	int cf;
14ce26e7 FB	122	target_long src1, src2;
2c0262af FB	123	src1 = CC_DST + CC_SRC;
	124	src2 = CC_SRC;
	125	cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
	126	return cf;
	127	}
	128
	129	static int glue(compute_all_sbb, SUFFIX)(void)
	130	{
	131	int cf, pf, af, zf, sf, of;
14ce26e7	132	target_long src1, src2;
2c0262af FB	133	src1 = CC_DST + CC_SRC + 1;
	134	src2 = CC_SRC;
	135	cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
	136	pf = parity_table[(uint8_t)CC_DST];
	137	af = (CC_DST ^ src1 ^ src2) & 0x10;
	138	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	139	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	140	of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
	141	return cf \| pf \| af \| zf \| sf \| of;
	142	}
	143
	144	static int glue(compute_c_sbb, SUFFIX)(void)
	145	{
14ce26e7 FB	146	int cf;
14ce26e7 FB	147	target_long src1, src2;
2c0262af FB	148	src1 = CC_DST + CC_SRC + 1;
	149	src2 = CC_SRC;
	150	cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
	151	return cf;
	152	}
	153
	154	static int glue(compute_all_logic, SUFFIX)(void)
	155	{
	156	int cf, pf, af, zf, sf, of;
	157	cf = 0;
	158	pf = parity_table[(uint8_t)CC_DST];
	159	af = 0;
	160	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	161	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	162	of = 0;
	163	return cf \| pf \| af \| zf \| sf \| of;
	164	}
	165
	166	static int glue(compute_c_logic, SUFFIX)(void)
	167	{
	168	return 0;
	169	}
	170
	171	static int glue(compute_all_inc, SUFFIX)(void)
	172	{
	173	int cf, pf, af, zf, sf, of;
14ce26e7	174	target_long src1, src2;
2c0262af FB	175	src1 = CC_DST - 1;
	176	src2 = 1;
	177	cf = CC_SRC;
	178	pf = parity_table[(uint8_t)CC_DST];
	179	af = (CC_DST ^ src1 ^ src2) & 0x10;
	180	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	181	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	182	of = ((CC_DST & DATA_MASK) == SIGN_MASK) << 11;
	183	return cf \| pf \| af \| zf \| sf \| of;
	184	}
	185
	186	#if DATA_BITS == 32
	187	static int glue(compute_c_inc, SUFFIX)(void)
	188	{
	189	return CC_SRC;
	190	}
	191	#endif
	192
	193	static int glue(compute_all_dec, SUFFIX)(void)
	194	{
	195	int cf, pf, af, zf, sf, of;
14ce26e7	196	target_long src1, src2;
2c0262af FB	197	src1 = CC_DST + 1;
	198	src2 = 1;
	199	cf = CC_SRC;
	200	pf = parity_table[(uint8_t)CC_DST];
	201	af = (CC_DST ^ src1 ^ src2) & 0x10;
	202	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	203	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
14ce26e7	204	of = ((CC_DST & DATA_MASK) == ((target_ulong)SIGN_MASK - 1)) << 11;
2c0262af FB	205	return cf \| pf \| af \| zf \| sf \| of;
	206	}
	207
	208	static int glue(compute_all_shl, SUFFIX)(void)
	209	{
	210	int cf, pf, af, zf, sf, of;
	211	cf = (CC_SRC >> (DATA_BITS - 1)) & CC_C;
	212	pf = parity_table[(uint8_t)CC_DST];
	213	af = 0; /* undefined */
	214	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	215	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	216	/* of is defined if shift count == 1 */
	217	of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
	218	return cf \| pf \| af \| zf \| sf \| of;
	219	}
	220
	221	static int glue(compute_c_shl, SUFFIX)(void)
	222	{
	223	return (CC_SRC >> (DATA_BITS - 1)) & CC_C;
	224	}
	225
	226	#if DATA_BITS == 32
	227	static int glue(compute_c_sar, SUFFIX)(void)
	228	{
	229	return CC_SRC & 1;
	230	}
	231	#endif
	232
	233	static int glue(compute_all_sar, SUFFIX)(void)
	234	{
	235	int cf, pf, af, zf, sf, of;
	236	cf = CC_SRC & 1;
	237	pf = parity_table[(uint8_t)CC_DST];
	238	af = 0; /* undefined */
	239	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	240	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	241	/* of is defined if shift count == 1 */
	242	of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
	243	return cf \| pf \| af \| zf \| sf \| of;
	244	}
	245
d36cd60e FB	246	#if DATA_BITS == 32
	247	static int glue(compute_c_mul, SUFFIX)(void)
	248	{
	249	int cf;
	250	cf = (CC_SRC != 0);
	251	return cf;
	252	}
	253	#endif
	254
	255	/* NOTE: we compute the flags like the P4. On olders CPUs, only OF and
	256	CF are modified and it is slower to do that. */
	257	static int glue(compute_all_mul, SUFFIX)(void)
	258	{
	259	int cf, pf, af, zf, sf, of;
	260	cf = (CC_SRC != 0);
	261	pf = parity_table[(uint8_t)CC_DST];
	262	af = 0; /* undefined */
	263	zf = ((DATA_TYPE)CC_DST == 0) << 6;
	264	sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
	265	of = cf << 11;
	266	return cf \| pf \| af \| zf \| sf \| of;
	267	}
	268
2c0262af FB	269	/* various optimized jumps cases */
	270
	271	void OPPROTO glue(op_jb_sub, SUFFIX)(void)
	272	{
14ce26e7	273	target_long src1, src2;
2c0262af FB	274	src1 = CC_DST + CC_SRC;
	275	src2 = CC_SRC;
	276
	277	if ((DATA_TYPE)src1 < (DATA_TYPE)src2)
14ce26e7	278	GOTO_LABEL_PARAM(1);
2c0262af FB	279	FORCE_RET();
	280	}
	281
	282	void OPPROTO glue(op_jz_sub, SUFFIX)(void)
	283	{
	284	if ((DATA_TYPE)CC_DST == 0)
14ce26e7 FB	285	GOTO_LABEL_PARAM(1);
	286	FORCE_RET();
	287	}
	288
	289	void OPPROTO glue(op_jnz_sub, SUFFIX)(void)
	290	{
	291	if ((DATA_TYPE)CC_DST != 0)
	292	GOTO_LABEL_PARAM(1);
2c0262af FB	293	FORCE_RET();
	294	}
	295
	296	void OPPROTO glue(op_jbe_sub, SUFFIX)(void)
	297	{
14ce26e7	298	target_long src1, src2;
2c0262af FB	299	src1 = CC_DST + CC_SRC;
	300	src2 = CC_SRC;
	301
	302	if ((DATA_TYPE)src1 <= (DATA_TYPE)src2)
14ce26e7	303	GOTO_LABEL_PARAM(1);
2c0262af FB	304	FORCE_RET();
	305	}
	306
	307	void OPPROTO glue(op_js_sub, SUFFIX)(void)
	308	{
	309	if (CC_DST & SIGN_MASK)
14ce26e7	310	GOTO_LABEL_PARAM(1);
2c0262af FB	311	FORCE_RET();
	312	}
	313
	314	void OPPROTO glue(op_jl_sub, SUFFIX)(void)
	315	{
14ce26e7	316	target_long src1, src2;
2c0262af FB	317	src1 = CC_DST + CC_SRC;
	318	src2 = CC_SRC;
	319
	320	if ((DATA_STYPE)src1 < (DATA_STYPE)src2)
14ce26e7	321	GOTO_LABEL_PARAM(1);
2c0262af FB	322	FORCE_RET();
	323	}
	324
	325	void OPPROTO glue(op_jle_sub, SUFFIX)(void)
	326	{
14ce26e7	327	target_long src1, src2;
2c0262af FB	328	src1 = CC_DST + CC_SRC;
	329	src2 = CC_SRC;
	330
	331	if ((DATA_STYPE)src1 <= (DATA_STYPE)src2)
14ce26e7	332	GOTO_LABEL_PARAM(1);
2c0262af FB	333	FORCE_RET();
	334	}
	335
	336	/* oldies */
	337
	338	#if DATA_BITS >= 16
	339
	340	void OPPROTO glue(op_loopnz, SUFFIX)(void)
	341	{
0b9dc5e4	342	if ((DATA_TYPE)ECX != 0 && !(T0 & CC_Z))
14ce26e7	343	GOTO_LABEL_PARAM(1);
2c0262af FB	344	FORCE_RET();
	345	}
	346
	347	void OPPROTO glue(op_loopz, SUFFIX)(void)
	348	{
0b9dc5e4	349	if ((DATA_TYPE)ECX != 0 && (T0 & CC_Z))
14ce26e7	350	GOTO_LABEL_PARAM(1);
2c0262af FB	351	FORCE_RET();
	352	}
	353
14ce26e7	354	void OPPROTO glue(op_jz_ecx, SUFFIX)(void)
2c0262af	355	{
14ce26e7 FB	356	if ((DATA_TYPE)ECX == 0)
14ce26e7 FB	357	GOTO_LABEL_PARAM(1);
2c0262af FB	358	FORCE_RET();
	359	}
	360
14ce26e7	361	void OPPROTO glue(op_jnz_ecx, SUFFIX)(void)
2c0262af	362	{
14ce26e7 FB	363	if ((DATA_TYPE)ECX != 0)
14ce26e7 FB	364	GOTO_LABEL_PARAM(1);
2c0262af FB	365	FORCE_RET();
	366	}
	367
	368	#endif
	369
	370	/* various optimized set cases */
	371
	372	void OPPROTO glue(op_setb_T0_sub, SUFFIX)(void)
	373	{
14ce26e7	374	target_long src1, src2;
2c0262af FB	375	src1 = CC_DST + CC_SRC;
	376	src2 = CC_SRC;
	377
	378	T0 = ((DATA_TYPE)src1 < (DATA_TYPE)src2);
	379	}
	380
	381	void OPPROTO glue(op_setz_T0_sub, SUFFIX)(void)
	382	{
	383	T0 = ((DATA_TYPE)CC_DST == 0);
	384	}
	385
	386	void OPPROTO glue(op_setbe_T0_sub, SUFFIX)(void)
	387	{
14ce26e7	388	target_long src1, src2;
2c0262af FB	389	src1 = CC_DST + CC_SRC;
	390	src2 = CC_SRC;
	391
	392	T0 = ((DATA_TYPE)src1 <= (DATA_TYPE)src2);
	393	}
	394
	395	void OPPROTO glue(op_sets_T0_sub, SUFFIX)(void)
	396	{
	397	T0 = lshift(CC_DST, -(DATA_BITS - 1)) & 1;
	398	}
	399
	400	void OPPROTO glue(op_setl_T0_sub, SUFFIX)(void)
	401	{
14ce26e7	402	target_long src1, src2;
2c0262af FB	403	src1 = CC_DST + CC_SRC;
	404	src2 = CC_SRC;
	405
	406	T0 = ((DATA_STYPE)src1 < (DATA_STYPE)src2);
	407	}
	408
	409	void OPPROTO glue(op_setle_T0_sub, SUFFIX)(void)
	410	{
14ce26e7	411	target_long src1, src2;
2c0262af FB	412	src1 = CC_DST + CC_SRC;
	413	src2 = CC_SRC;
	414
	415	T0 = ((DATA_STYPE)src1 <= (DATA_STYPE)src2);
	416	}
	417
	418	/* shifts */
	419
	420	void OPPROTO glue(glue(op_shl, SUFFIX), _T0_T1)(void)
	421	{
	422	int count;
14ce26e7	423	count = T1 & SHIFT1_MASK;
2c0262af FB	424	T0 = T0 << count;
	425	FORCE_RET();
	426	}
	427
	428	void OPPROTO glue(glue(op_shr, SUFFIX), _T0_T1)(void)
	429	{
	430	int count;
14ce26e7	431	count = T1 & SHIFT1_MASK;
2c0262af FB	432	T0 &= DATA_MASK;
	433	T0 = T0 >> count;
	434	FORCE_RET();
	435	}
	436
	437	void OPPROTO glue(glue(op_sar, SUFFIX), _T0_T1)(void)
	438	{
14ce26e7 FB	439	int count;
	440	target_long src;
	441
	442	count = T1 & SHIFT1_MASK;
2c0262af FB	443	src = (DATA_STYPE)T0;
	444	T0 = src >> count;
	445	FORCE_RET();
	446	}
	447
	448	#undef MEM_WRITE
	449	#include "ops_template_mem.h"
	450
34e01bbf	451	#define MEM_WRITE 0
2c0262af FB	452	#include "ops_template_mem.h"
2c0262af FB	453
34e01bbf FB	454	#if !defined(CONFIG_USER_ONLY)
	455	#define MEM_WRITE 1
	456	#include "ops_template_mem.h"
	457
	458	#define MEM_WRITE 2
	459	#include "ops_template_mem.h"
	460	#endif
	461
2c0262af FB	462	/* bit operations */
	463	#if DATA_BITS >= 16
	464
	465	void OPPROTO glue(glue(op_bt, SUFFIX), _T0_T1_cc)(void)
	466	{
	467	int count;
	468	count = T1 & SHIFT_MASK;
	469	CC_SRC = T0 >> count;
	470	}
	471
	472	void OPPROTO glue(glue(op_bts, SUFFIX), _T0_T1_cc)(void)
	473	{
	474	int count;
	475	count = T1 & SHIFT_MASK;
	476	T1 = T0 >> count;
14ce26e7	477	T0 \|= (((target_long)1) << count);
2c0262af FB	478	}
	479
	480	void OPPROTO glue(glue(op_btr, SUFFIX), _T0_T1_cc)(void)
	481	{
	482	int count;
	483	count = T1 & SHIFT_MASK;
	484	T1 = T0 >> count;
14ce26e7	485	T0 &= ~(((target_long)1) << count);
2c0262af FB	486	}
	487
	488	void OPPROTO glue(glue(op_btc, SUFFIX), _T0_T1_cc)(void)
	489	{
	490	int count;
	491	count = T1 & SHIFT_MASK;
	492	T1 = T0 >> count;
14ce26e7 FB	493	T0 ^= (((target_long)1) << count);
	494	}
	495
	496	void OPPROTO glue(glue(op_add_bit, SUFFIX), _A0_T1)(void)
	497	{
	498	A0 += ((DATA_STYPE)T1 >> (3 + SHIFT)) << SHIFT;
2c0262af FB	499	}
	500
	501	void OPPROTO glue(glue(op_bsf, SUFFIX), _T0_cc)(void)
	502	{
14ce26e7 FB	503	int count;
	504	target_long res;
	505
2c0262af FB	506	res = T0 & DATA_MASK;
	507	if (res != 0) {
	508	count = 0;
	509	while ((res & 1) == 0) {
	510	count++;
	511	res >>= 1;
	512	}
686f3f26	513	T1 = count;
debf7a7c	514	CC_DST = 1; /* ZF = 0 */
2c0262af FB	515	} else {
	516	CC_DST = 0; /* ZF = 1 */
	517	}
	518	FORCE_RET();
	519	}
	520
	521	void OPPROTO glue(glue(op_bsr, SUFFIX), _T0_cc)(void)
	522	{
14ce26e7 FB	523	int count;
	524	target_long res;
	525
2c0262af FB	526	res = T0 & DATA_MASK;
	527	if (res != 0) {
	528	count = DATA_BITS - 1;
	529	while ((res & SIGN_MASK) == 0) {
	530	count--;
	531	res <<= 1;
	532	}
686f3f26	533	T1 = count;
debf7a7c	534	CC_DST = 1; /* ZF = 0 */
2c0262af FB	535	} else {
	536	CC_DST = 0; /* ZF = 1 */
	537	}
	538	FORCE_RET();
	539	}
	540
	541	#endif
	542
	543	#if DATA_BITS == 32
	544	void OPPROTO op_update_bt_cc(void)
	545	{
	546	CC_SRC = T1;
	547	}
	548	#endif
	549
	550	/* string operations */
	551
	552	void OPPROTO glue(op_movl_T0_Dshift, SUFFIX)(void)
	553	{
	554	T0 = DF << SHIFT;
	555	}
	556
2c0262af	557	/* port I/O */
14ce26e7	558	#if DATA_BITS <= 32
2c0262af FB	559	void OPPROTO glue(glue(op_out, SUFFIX), _T0_T1)(void)
2c0262af FB	560	{
4487d0ac	561	glue(cpu_out, SUFFIX)(env, T0, T1 & DATA_MASK);
2c0262af FB	562	}
	563
	564	void OPPROTO glue(glue(op_in, SUFFIX), _T0_T1)(void)
	565	{
4487d0ac	566	T1 = glue(cpu_in, SUFFIX)(env, T0);
2c0262af FB	567	}
	568
	569	void OPPROTO glue(glue(op_in, SUFFIX), _DX_T0)(void)
	570	{
4487d0ac	571	T0 = glue(cpu_in, SUFFIX)(env, EDX & 0xffff);
2c0262af FB	572	}
	573
	574	void OPPROTO glue(glue(op_out, SUFFIX), _DX_T0)(void)
	575	{
4487d0ac	576	glue(cpu_out, SUFFIX)(env, EDX & 0xffff, T0);
2c0262af FB	577	}
2c0262af FB	578
3e25f951 FB	579	void OPPROTO glue(glue(op_check_io, SUFFIX), _T0)(void)
	580	{
	581	glue(glue(check_io, SUFFIX), _T0)();
	582	}
	583
	584	void OPPROTO glue(glue(op_check_io, SUFFIX), _DX)(void)
	585	{
	586	glue(glue(check_io, SUFFIX), _DX)();
	587	}
14ce26e7	588	#endif
3e25f951	589
2c0262af FB	590	#undef DATA_BITS
2c0262af FB	591	#undef SHIFT_MASK
14ce26e7	592	#undef SHIFT1_MASK
2c0262af FB	593	#undef SIGN_MASK
	594	#undef DATA_TYPE
	595	#undef DATA_STYPE
	596	#undef DATA_MASK
	597	#undef SUFFIX