[mirror_qemu.git] / target-i386 / int_helper.c

/*
 *  x86 integer helpers
 *
 *  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, see <http://www.gnu.org/licenses/>.
 */

#include "cpu.h"
#include "dyngen-exec.h"
#include "host-utils.h"
#include "helper.h"

//#define DEBUG_MULDIV

/* modulo 9 table */
static const uint8_t rclb_table[32] = {
    0, 1, 2, 3, 4, 5, 6, 7,
    8, 0, 1, 2, 3, 4, 5, 6,
    7, 8, 0, 1, 2, 3, 4, 5,
    6, 7, 8, 0, 1, 2, 3, 4,
};

/* modulo 17 table */
static const uint8_t rclw_table[32] = {
    0, 1, 2, 3, 4, 5, 6, 7,
    8, 9, 10, 11, 12, 13, 14, 15,
    16, 0, 1, 2, 3, 4, 5, 6,
    7, 8, 9, 10, 11, 12, 13, 14,
};

/* division, flags are undefined */

void helper_divb_AL(target_ulong t0)
{
    unsigned int num, den, q, r;

    num = (EAX & 0xffff);
    den = (t0 & 0xff);
    if (den == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q = (num / den);
    if (q > 0xff) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q &= 0xff;
    r = (num % den) & 0xff;
    EAX = (EAX & ~0xffff) | (r << 8) | q;
}

void helper_idivb_AL(target_ulong t0)
{
    int num, den, q, r;

    num = (int16_t)EAX;
    den = (int8_t)t0;
    if (den == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q = (num / den);
    if (q != (int8_t)q) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q &= 0xff;
    r = (num % den) & 0xff;
    EAX = (EAX & ~0xffff) | (r << 8) | q;
}

void helper_divw_AX(target_ulong t0)
{
    unsigned int num, den, q, r;

    num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
    den = (t0 & 0xffff);
    if (den == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q = (num / den);
    if (q > 0xffff) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q &= 0xffff;
    r = (num % den) & 0xffff;
    EAX = (EAX & ~0xffff) | q;
    EDX = (EDX & ~0xffff) | r;
}

void helper_idivw_AX(target_ulong t0)
{
    int num, den, q, r;

    num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
    den = (int16_t)t0;
    if (den == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q = (num / den);
    if (q != (int16_t)q) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q &= 0xffff;
    r = (num % den) & 0xffff;
    EAX = (EAX & ~0xffff) | q;
    EDX = (EDX & ~0xffff) | r;
}

void helper_divl_EAX(target_ulong t0)
{
    unsigned int den, r;
    uint64_t num, q;

    num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
    den = t0;
    if (den == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q = (num / den);
    r = (num % den);
    if (q > 0xffffffff) {
        raise_exception(env, EXCP00_DIVZ);
    }
    EAX = (uint32_t)q;
    EDX = (uint32_t)r;
}

void helper_idivl_EAX(target_ulong t0)
{
    int den, r;
    int64_t num, q;

    num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
    den = t0;
    if (den == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    q = (num / den);
    r = (num % den);
    if (q != (int32_t)q) {
        raise_exception(env, EXCP00_DIVZ);
    }
    EAX = (uint32_t)q;
    EDX = (uint32_t)r;
}

/* bcd */

/* XXX: exception */
void helper_aam(int base)
{
    int al, ah;

    al = EAX & 0xff;
    ah = al / base;
    al = al % base;
    EAX = (EAX & ~0xffff) | al | (ah << 8);
    CC_DST = al;
}

void helper_aad(int base)
{
    int al, ah;

    al = EAX & 0xff;
    ah = (EAX >> 8) & 0xff;
    al = ((ah * base) + al) & 0xff;
    EAX = (EAX & ~0xffff) | al;
    CC_DST = al;
}

void helper_aaa(void)
{
    int icarry;
    int al, ah, af;
    int eflags;

    eflags = helper_cc_compute_all(CC_OP);
    af = eflags & CC_A;
    al = EAX & 0xff;
    ah = (EAX >> 8) & 0xff;

    icarry = (al > 0xf9);
    if (((al & 0x0f) > 9) || af) {
        al = (al + 6) & 0x0f;
        ah = (ah + 1 + icarry) & 0xff;
        eflags |= CC_C | CC_A;
    } else {
        eflags &= ~(CC_C | CC_A);
        al &= 0x0f;
    }
    EAX = (EAX & ~0xffff) | al | (ah << 8);
    CC_SRC = eflags;
}

void helper_aas(void)
{
    int icarry;
    int al, ah, af;
    int eflags;

    eflags = helper_cc_compute_all(CC_OP);
    af = eflags & CC_A;
    al = EAX & 0xff;
    ah = (EAX >> 8) & 0xff;

    icarry = (al < 6);
    if (((al & 0x0f) > 9) || af) {
        al = (al - 6) & 0x0f;
        ah = (ah - 1 - icarry) & 0xff;
        eflags |= CC_C | CC_A;
    } else {
        eflags &= ~(CC_C | CC_A);
        al &= 0x0f;
    }
    EAX = (EAX & ~0xffff) | al | (ah << 8);
    CC_SRC = eflags;
}

void helper_daa(void)
{
    int old_al, al, af, cf;
    int eflags;

    eflags = helper_cc_compute_all(CC_OP);
    cf = eflags & CC_C;
    af = eflags & CC_A;
    old_al = al = EAX & 0xff;

    eflags = 0;
    if (((al & 0x0f) > 9) || af) {
        al = (al + 6) & 0xff;
        eflags |= CC_A;
    }
    if ((old_al > 0x99) || cf) {
        al = (al + 0x60) & 0xff;
        eflags |= CC_C;
    }
    EAX = (EAX & ~0xff) | al;
    /* well, speed is not an issue here, so we compute the flags by hand */
    eflags |= (al == 0) << 6; /* zf */
    eflags |= parity_table[al]; /* pf */
    eflags |= (al & 0x80); /* sf */
    CC_SRC = eflags;
}

void helper_das(void)
{
    int al, al1, af, cf;
    int eflags;

    eflags = helper_cc_compute_all(CC_OP);
    cf = eflags & CC_C;
    af = eflags & CC_A;
    al = EAX & 0xff;

    eflags = 0;
    al1 = al;
    if (((al & 0x0f) > 9) || af) {
        eflags |= CC_A;
        if (al < 6 || cf) {
            eflags |= CC_C;
        }
        al = (al - 6) & 0xff;
    }
    if ((al1 > 0x99) || cf) {
        al = (al - 0x60) & 0xff;
        eflags |= CC_C;
    }
    EAX = (EAX & ~0xff) | al;
    /* well, speed is not an issue here, so we compute the flags by hand */
    eflags |= (al == 0) << 6; /* zf */
    eflags |= parity_table[al]; /* pf */
    eflags |= (al & 0x80); /* sf */
    CC_SRC = eflags;
}

#ifdef TARGET_X86_64
static void add128(uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)
{
    *plow += a;
    /* carry test */
    if (*plow < a) {
        (*phigh)++;
    }
    *phigh += b;
}

static void neg128(uint64_t *plow, uint64_t *phigh)
{
    *plow = ~*plow;
    *phigh = ~*phigh;
    add128(plow, phigh, 1, 0);
}

/* return TRUE if overflow */
static int div64(uint64_t *plow, uint64_t *phigh, uint64_t b)
{
    uint64_t q, r, a1, a0;
    int i, qb, ab;

    a0 = *plow;
    a1 = *phigh;
    if (a1 == 0) {
        q = a0 / b;
        r = a0 % b;
        *plow = q;
        *phigh = r;
    } else {
        if (a1 >= b) {
            return 1;
        }
        /* XXX: use a better algorithm */
        for (i = 0; i < 64; i++) {
            ab = a1 >> 63;
            a1 = (a1 << 1) | (a0 >> 63);
            if (ab || a1 >= b) {
                a1 -= b;
                qb = 1;
            } else {
                qb = 0;
            }
            a0 = (a0 << 1) | qb;
        }
#if defined(DEBUG_MULDIV)
        printf("div: 0x%016" PRIx64 "%016" PRIx64 " / 0x%016" PRIx64
               ": q=0x%016" PRIx64 " r=0x%016" PRIx64 "\n",
               *phigh, *plow, b, a0, a1);
#endif
        *plow = a0;
        *phigh = a1;
    }
    return 0;
}

/* return TRUE if overflow */
static int idiv64(uint64_t *plow, uint64_t *phigh, int64_t b)
{
    int sa, sb;

    sa = ((int64_t)*phigh < 0);
    if (sa) {
        neg128(plow, phigh);
    }
    sb = (b < 0);
    if (sb) {
        b = -b;
    }
    if (div64(plow, phigh, b) != 0) {
        return 1;
    }
    if (sa ^ sb) {
        if (*plow > (1ULL << 63)) {
            return 1;
        }
        *plow = -*plow;
    } else {
        if (*plow >= (1ULL << 63)) {
            return 1;
        }
    }
    if (sa) {
        *phigh = -*phigh;
    }
    return 0;
}

void helper_mulq_EAX_T0(target_ulong t0)
{
    uint64_t r0, r1;

    mulu64(&r0, &r1, EAX, t0);
    EAX = r0;
    EDX = r1;
    CC_DST = r0;
    CC_SRC = r1;
}

void helper_imulq_EAX_T0(target_ulong t0)
{
    uint64_t r0, r1;

    muls64(&r0, &r1, EAX, t0);
    EAX = r0;
    EDX = r1;
    CC_DST = r0;
    CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
}

target_ulong helper_imulq_T0_T1(target_ulong t0, target_ulong t1)
{
    uint64_t r0, r1;

    muls64(&r0, &r1, t0, t1);
    CC_DST = r0;
    CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
    return r0;
}

void helper_divq_EAX(target_ulong t0)
{
    uint64_t r0, r1;

    if (t0 == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    r0 = EAX;
    r1 = EDX;
    if (div64(&r0, &r1, t0)) {
        raise_exception(env, EXCP00_DIVZ);
    }
    EAX = r0;
    EDX = r1;
}

void helper_idivq_EAX(target_ulong t0)
{
    uint64_t r0, r1;

    if (t0 == 0) {
        raise_exception(env, EXCP00_DIVZ);
    }
    r0 = EAX;
    r1 = EDX;
    if (idiv64(&r0, &r1, t0)) {
        raise_exception(env, EXCP00_DIVZ);
    }
    EAX = r0;
    EDX = r1;
}
#endif

/* bit operations */
target_ulong helper_bsf(target_ulong t0)
{
    int count;
    target_ulong res;

    res = t0;
    count = 0;
    while ((res & 1) == 0) {
        count++;
        res >>= 1;
    }
    return count;
}

target_ulong helper_lzcnt(target_ulong t0, int wordsize)
{
    int count;
    target_ulong res, mask;

    if (wordsize > 0 && t0 == 0) {
        return wordsize;
    }
    res = t0;
    count = TARGET_LONG_BITS - 1;
    mask = (target_ulong)1 << (TARGET_LONG_BITS - 1);
    while ((res & mask) == 0) {
        count--;
        res <<= 1;
    }
    if (wordsize > 0) {
        return wordsize - 1 - count;
    }
    return count;
}

target_ulong helper_bsr(target_ulong t0)
{
    return helper_lzcnt(t0, 0);
}

#define SHIFT 0
#include "shift_helper_template.h"
#undef SHIFT

#define SHIFT 1
#include "shift_helper_template.h"
#undef SHIFT

#define SHIFT 2
#include "shift_helper_template.h"
#undef SHIFT

#ifdef TARGET_X86_64
#define SHIFT 3
#include "shift_helper_template.h"
#undef SHIFT
#endif
Commit	Line	Data
d7582078 BS	1	/*
	2	* x86 integer helpers
	3	*
	4	* Copyright (c) 2003 Fabrice Bellard
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2 of the License, or (at your option) any later version.
	10	*
	11	* This library is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include "cpu.h"
	21	#include "dyngen-exec.h"
	22	#include "host-utils.h"
	23	#include "helper.h"
	24
	25	//#define DEBUG_MULDIV
	26
	27	/* modulo 9 table */
	28	static const uint8_t rclb_table[32] = {
	29	0, 1, 2, 3, 4, 5, 6, 7,
	30	8, 0, 1, 2, 3, 4, 5, 6,
	31	7, 8, 0, 1, 2, 3, 4, 5,
	32	6, 7, 8, 0, 1, 2, 3, 4,
	33	};
	34
	35	/* modulo 17 table */
	36	static const uint8_t rclw_table[32] = {
	37	0, 1, 2, 3, 4, 5, 6, 7,
	38	8, 9, 10, 11, 12, 13, 14, 15,
	39	16, 0, 1, 2, 3, 4, 5, 6,
	40	7, 8, 9, 10, 11, 12, 13, 14,
	41	};
	42
	43	/* division, flags are undefined */
	44
	45	void helper_divb_AL(target_ulong t0)
	46	{
	47	unsigned int num, den, q, r;
	48
	49	num = (EAX & 0xffff);
	50	den = (t0 & 0xff);
	51	if (den == 0) {
	52	raise_exception(env, EXCP00_DIVZ);
	53	}
	54	q = (num / den);
	55	if (q > 0xff) {
	56	raise_exception(env, EXCP00_DIVZ);
	57	}
	58	q &= 0xff;
	59	r = (num % den) & 0xff;
	60	EAX = (EAX & ~0xffff) \| (r << 8) \| q;
	61	}
	62
	63	void helper_idivb_AL(target_ulong t0)
	64	{
65	int num, den, q, r;
66
67	num = (int16_t)EAX;
68	den = (int8_t)t0;
69	if (den == 0) {
70	raise_exception(env, EXCP00_DIVZ);
71	}
72	q = (num / den);
73	if (q != (int8_t)q) {
74	raise_exception(env, EXCP00_DIVZ);
75	}
76	q &= 0xff;
77	r = (num % den) & 0xff;
78	EAX = (EAX & ~0xffff) \| (r << 8) \| q;
79	}
80
81	void helper_divw_AX(target_ulong t0)
82	{
83	unsigned int num, den, q, r;
84
85	num = (EAX & 0xffff) \| ((EDX & 0xffff) << 16);
86	den = (t0 & 0xffff);
87	if (den == 0) {
88	raise_exception(env, EXCP00_DIVZ);
89	}
90	q = (num / den);
91	if (q > 0xffff) {
92	raise_exception(env, EXCP00_DIVZ);
93	}
94	q &= 0xffff;
95	r = (num % den) & 0xffff;
96	EAX = (EAX & ~0xffff) \| q;
97	EDX = (EDX & ~0xffff) \| r;
98	}
99
100	void helper_idivw_AX(target_ulong t0)
101	{
102	int num, den, q, r;
103
104	num = (EAX & 0xffff) \| ((EDX & 0xffff) << 16);
105	den = (int16_t)t0;
106	if (den == 0) {
107	raise_exception(env, EXCP00_DIVZ);
108	}
109	q = (num / den);
110	if (q != (int16_t)q) {
111	raise_exception(env, EXCP00_DIVZ);
112	}
113	q &= 0xffff;
114	r = (num % den) & 0xffff;
115	EAX = (EAX & ~0xffff) \| q;
116	EDX = (EDX & ~0xffff) \| r;
117	}
118
119	void helper_divl_EAX(target_ulong t0)
120	{
121	unsigned int den, r;
122	uint64_t num, q;
123
124	num = ((uint32_t)EAX) \| ((uint64_t)((uint32_t)EDX) << 32);
125	den = t0;
126	if (den == 0) {
127	raise_exception(env, EXCP00_DIVZ);
128	}
129	q = (num / den);
130	r = (num % den);
131	if (q > 0xffffffff) {
132	raise_exception(env, EXCP00_DIVZ);
133	}
134	EAX = (uint32_t)q;
135	EDX = (uint32_t)r;
136	}
137
138	void helper_idivl_EAX(target_ulong t0)
139	{
140	int den, r;
141	int64_t num, q;
142
143	num = ((uint32_t)EAX) \| ((uint64_t)((uint32_t)EDX) << 32);
144	den = t0;
145	if (den == 0) {
146	raise_exception(env, EXCP00_DIVZ);
147	}
148	q = (num / den);
149	r = (num % den);
150	if (q != (int32_t)q) {
151	raise_exception(env, EXCP00_DIVZ);
152	}
153	EAX = (uint32_t)q;
154	EDX = (uint32_t)r;
155	}
156
157	/* bcd */
158
159	/* XXX: exception */
160	void helper_aam(int base)
161	{
162	int al, ah;
163
164	al = EAX & 0xff;
165	ah = al / base;
166	al = al % base;
167	EAX = (EAX & ~0xffff) \| al \| (ah << 8);
168	CC_DST = al;
169	}
170
171	void helper_aad(int base)
172	{
173	int al, ah;
174
175	al = EAX & 0xff;
176	ah = (EAX >> 8) & 0xff;
177	al = ((ah * base) + al) & 0xff;
178	EAX = (EAX & ~0xffff) \| al;
179	CC_DST = al;
180	}
181
182	void helper_aaa(void)
183	{
184	int icarry;
185	int al, ah, af;
186	int eflags;
187
188	eflags = helper_cc_compute_all(CC_OP);
189	af = eflags & CC_A;
190	al = EAX & 0xff;
191	ah = (EAX >> 8) & 0xff;
192
193	icarry = (al > 0xf9);
194	if (((al & 0x0f) > 9) \|\| af) {
195	al = (al + 6) & 0x0f;
196	ah = (ah + 1 + icarry) & 0xff;
197	eflags \|= CC_C \| CC_A;
198	} else {
199	eflags &= ~(CC_C \| CC_A);
200	al &= 0x0f;
201	}
202	EAX = (EAX & ~0xffff) \| al \| (ah << 8);
203	CC_SRC = eflags;
204	}
205
206	void helper_aas(void)
207	{
208	int icarry;
209	int al, ah, af;
210	int eflags;
211
212	eflags = helper_cc_compute_all(CC_OP);
213	af = eflags & CC_A;
214	al = EAX & 0xff;
215	ah = (EAX >> 8) & 0xff;
216
217	icarry = (al < 6);
218	if (((al & 0x0f) > 9) \|\| af) {
219	al = (al - 6) & 0x0f;
220	ah = (ah - 1 - icarry) & 0xff;
221	eflags \|= CC_C \| CC_A;
222	} else {
223	eflags &= ~(CC_C \| CC_A);
224	al &= 0x0f;
225	}
226	EAX = (EAX & ~0xffff) \| al \| (ah << 8);
227	CC_SRC = eflags;
228	}
229
230	void helper_daa(void)
231	{
232	int old_al, al, af, cf;
233	int eflags;
234
235	eflags = helper_cc_compute_all(CC_OP);
236	cf = eflags & CC_C;
237	af = eflags & CC_A;
238	old_al = al = EAX & 0xff;
239
240	eflags = 0;
241	if (((al & 0x0f) > 9) \|\| af) {
242	al = (al + 6) & 0xff;
243	eflags \|= CC_A;
244	}
245	if ((old_al > 0x99) \|\| cf) {
246	al = (al + 0x60) & 0xff;
247	eflags \|= CC_C;
248	}
249	EAX = (EAX & ~0xff) \| al;
250	/* well, speed is not an issue here, so we compute the flags by hand */
251	eflags \|= (al == 0) << 6; /* zf */
252	eflags \|= parity_table[al]; /* pf */
253	eflags \|= (al & 0x80); /* sf */
254	CC_SRC = eflags;
255	}
256
257	void helper_das(void)
258	{
259	int al, al1, af, cf;
260	int eflags;
261
262	eflags = helper_cc_compute_all(CC_OP);
263	cf = eflags & CC_C;
264	af = eflags & CC_A;
265	al = EAX & 0xff;
266
267	eflags = 0;
268	al1 = al;
269	if (((al & 0x0f) > 9) \|\| af) {
270	eflags \|= CC_A;
271	if (al < 6 \|\| cf) {
272	eflags \|= CC_C;
273	}
274	al = (al - 6) & 0xff;
275	}
276	if ((al1 > 0x99) \|\| cf) {
277	al = (al - 0x60) & 0xff;
278	eflags \|= CC_C;
279	}
280	EAX = (EAX & ~0xff) \| al;
281	/* well, speed is not an issue here, so we compute the flags by hand */
282	eflags \|= (al == 0) << 6; /* zf */
283	eflags \|= parity_table[al]; /* pf */
284	eflags \|= (al & 0x80); /* sf */
285	CC_SRC = eflags;
286	}
287
288	#ifdef TARGET_X86_64
289	static void add128(uint64_t plow, uint64_t phigh, uint64_t a, uint64_t b)
290	{
291	*plow += a;
292	/* carry test */
293	if (*plow < a) {
294	(*phigh)++;
295	}
296	*phigh += b;
297	}
298
299	static void neg128(uint64_t plow, uint64_t phigh)
300	{
301	plow = ~plow;
302	phigh = ~phigh;
303	add128(plow, phigh, 1, 0);
304	}
305
306	/* return TRUE if overflow */
307	static int div64(uint64_t plow, uint64_t phigh, uint64_t b)
308	{
309	uint64_t q, r, a1, a0;
310	int i, qb, ab;
311
312	a0 = *plow;
313	a1 = *phigh;
314	if (a1 == 0) {
315	q = a0 / b;
316	r = a0 % b;
317	*plow = q;
318	*phigh = r;
319	} else {
320	if (a1 >= b) {
321	return 1;
322	}
323	/* XXX: use a better algorithm */
324	for (i = 0; i < 64; i++) {
325	ab = a1 >> 63;
326	a1 = (a1 << 1) \| (a0 >> 63);
327	if (ab \|\| a1 >= b) {
328	a1 -= b;
329	qb = 1;
330	} else {
331	qb = 0;
332	}
333	a0 = (a0 << 1) \| qb;
334	}
335	#if defined(DEBUG_MULDIV)
336	printf("div: 0x%016" PRIx64 "%016" PRIx64 " / 0x%016" PRIx64
337	": q=0x%016" PRIx64 " r=0x%016" PRIx64 "\n",
338	phigh, plow, b, a0, a1);
339	#endif
340	*plow = a0;
341	*phigh = a1;
342	}
343	return 0;
344	}
345
346	/* return TRUE if overflow */
347	static int idiv64(uint64_t plow, uint64_t phigh, int64_t b)
348	{
349	int sa, sb;
350
351	sa = ((int64_t)*phigh < 0);
352	if (sa) {
353	neg128(plow, phigh);
354	}
355	sb = (b < 0);
356	if (sb) {
357	b = -b;
358	}
359	if (div64(plow, phigh, b) != 0) {
360	return 1;
361	}
362	if (sa ^ sb) {
363	if (*plow > (1ULL << 63)) {
364	return 1;
365	}
366	plow = -plow;
367	} else {
368	if (*plow >= (1ULL << 63)) {
369	return 1;
370	}
371	}
372	if (sa) {
373	phigh = -phigh;
374	}
375	return 0;
376	}
377
378	void helper_mulq_EAX_T0(target_ulong t0)
379	{
380	uint64_t r0, r1;
381
382	mulu64(&r0, &r1, EAX, t0);
383	EAX = r0;
384	EDX = r1;
385	CC_DST = r0;
386	CC_SRC = r1;
387	}
388
389	void helper_imulq_EAX_T0(target_ulong t0)
390	{
391	uint64_t r0, r1;
392
393	muls64(&r0, &r1, EAX, t0);
394	EAX = r0;
395	EDX = r1;
396	CC_DST = r0;
397	CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
398	}
399
400	target_ulong helper_imulq_T0_T1(target_ulong t0, target_ulong t1)
401	{
402	uint64_t r0, r1;
403
404	muls64(&r0, &r1, t0, t1);
405	CC_DST = r0;
406	CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
407	return r0;
408	}
409
410	void helper_divq_EAX(target_ulong t0)
411	{
412	uint64_t r0, r1;
413
414	if (t0 == 0) {
415	raise_exception(env, EXCP00_DIVZ);
416	}
417	r0 = EAX;
418	r1 = EDX;
419	if (div64(&r0, &r1, t0)) {
420	raise_exception(env, EXCP00_DIVZ);
421	}
422	EAX = r0;
423	EDX = r1;
424	}
425
426	void helper_idivq_EAX(target_ulong t0)
427	{
428	uint64_t r0, r1;
429
430	if (t0 == 0) {
431	raise_exception(env, EXCP00_DIVZ);
432	}
433	r0 = EAX;
434	r1 = EDX;
435	if (idiv64(&r0, &r1, t0)) {
436	raise_exception(env, EXCP00_DIVZ);
437	}
438	EAX = r0;
439	EDX = r1;
440	}
441	#endif
442
443	/* bit operations */
444	target_ulong helper_bsf(target_ulong t0)
445	{
446	int count;
447	target_ulong res;
448
449	res = t0;
450	count = 0;
451	while ((res & 1) == 0) {
452	count++;
453	res >>= 1;
454	}
455	return count;
456	}
457
458	target_ulong helper_lzcnt(target_ulong t0, int wordsize)
459	{
460	int count;
461	target_ulong res, mask;
462
463	if (wordsize > 0 && t0 == 0) {
464	return wordsize;
465	}
466	res = t0;
467	count = TARGET_LONG_BITS - 1;
468	mask = (target_ulong)1 << (TARGET_LONG_BITS - 1);
469	while ((res & mask) == 0) {
470	count--;
471	res <<= 1;
472	}
473	if (wordsize > 0) {
474	return wordsize - 1 - count;
475	}
476	return count;
477	}
478
479	target_ulong helper_bsr(target_ulong t0)
480	{
481	return helper_lzcnt(t0, 0);
482	}
483
484	#define SHIFT 0
485	#include "shift_helper_template.h"
486	#undef SHIFT
487
488	#define SHIFT 1
489	#include "shift_helper_template.h"
490	#undef SHIFT
491
492	#define SHIFT 2
493	#include "shift_helper_template.h"
494	#undef SHIFT
495
496	#ifdef TARGET_X86_64
497	#define SHIFT 3
498	#include "shift_helper_template.h"
499	#undef SHIFT
500	#endif