[qemu.git] / exec-i386.h

/*
 *  i386 execution defines 
 *
 *  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
 */
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;

typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef signed long long int64_t;

#define bswap32(x) \
({ \
	uint32_t __x = (x); \
	((uint32_t)( \
		(((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | \
		(((uint32_t)(__x) & (uint32_t)0x0000ff00UL) <<  8) | \
		(((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >>  8) | \
		(((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) )); \
})

#define NULL 0
#include <fenv.h>

typedef struct FILE FILE;
extern FILE *logfile;
extern int loglevel;
extern int fprintf(FILE *, const char *, ...);
extern int printf(const char *, ...);

#ifdef __i386__
register unsigned int T0 asm("ebx");
register unsigned int T1 asm("esi");
register unsigned int A0 asm("edi");
register struct CPUX86State *env asm("ebp");
#endif
#ifdef __powerpc__
register unsigned int EAX asm("r16");
register unsigned int ECX asm("r17");
register unsigned int EDX asm("r18");
register unsigned int EBX asm("r19");
register unsigned int ESP asm("r20");
register unsigned int EBP asm("r21");
register unsigned int ESI asm("r22");
register unsigned int EDI asm("r23");
register unsigned int T0 asm("r24");
register unsigned int T1 asm("r25");
register unsigned int A0 asm("r26");
register struct CPUX86State *env asm("r27");
#define USE_INT_TO_FLOAT_HELPERS
#define BUGGY_GCC_DIV64
#define reg_EAX
#define reg_ECX
#define reg_EDX
#define reg_EBX
#define reg_ESP
#define reg_EBP
#define reg_ESI
#define reg_EDI
#endif
#ifdef __arm__
register unsigned int T0 asm("r4");
register unsigned int T1 asm("r5");
register unsigned int A0 asm("r6");
register struct CPUX86State *env asm("r7");
#endif
#ifdef __mips__
register unsigned int T0 asm("s0");
register unsigned int T1 asm("s1");
register unsigned int A0 asm("s2");
register struct CPUX86State *env asm("s3");
#endif
#ifdef __sparc__
register unsigned int EAX asm("l0");
register unsigned int ECX asm("l1");
register unsigned int EDX asm("l2");
register unsigned int EBX asm("l3");
register unsigned int ESP asm("l4");
register unsigned int EBP asm("l5");
register unsigned int ESI asm("l6");
register unsigned int EDI asm("l7");
register unsigned int T0 asm("g1");
register unsigned int T1 asm("g2");
register unsigned int A0 asm("g3");
register struct CPUX86State *env asm("g6");
#define USE_FP_CONVERT
#define reg_EAX
#define reg_ECX
#define reg_EDX
#define reg_EBX
#define reg_ESP
#define reg_EBP
#define reg_ESI
#define reg_EDI
#endif
#ifdef __s390__
register unsigned int T0 asm("r7");
register unsigned int T1 asm("r8");
register unsigned int A0 asm("r9");
register struct CPUX86State *env asm("r10");
#endif
#ifdef __alpha__
register unsigned int T0 asm("$9");
register unsigned int T1 asm("$10");
register unsigned int A0 asm("$11");
register unsigned int EAX asm("$12");
register unsigned int ESP asm("$13");
register unsigned int EBP asm("$14");
/* Note $15 is the frame pointer, so anything in op-i386.c that would
   require a frame pointer, like alloca, would probably loose.  */
register struct CPUX86State *env asm("$15");
#define reg_EAX
#define reg_ESP
#define reg_EBP
#endif
#ifdef __ia64__
register unsigned int T0 asm("r24");
register unsigned int T1 asm("r25");
register unsigned int A0 asm("r26");
register struct CPUX86State *env asm("r27");
#endif

/* force GCC to generate only one epilog at the end of the function */
#define FORCE_RET() asm volatile ("");

#ifndef OPPROTO
#define OPPROTO
#endif

#define xglue(x, y) x ## y
#define glue(x, y) xglue(x, y)

#ifndef reg_EAX
#define EAX (env->regs[R_EAX])
#endif
#ifndef reg_ECX
#define ECX (env->regs[R_ECX])
#endif
#ifndef reg_EDX
#define EDX (env->regs[R_EDX])
#endif
#ifndef reg_EBX
#define EBX (env->regs[R_EBX])
#endif
#ifndef reg_ESP
#define ESP (env->regs[R_ESP])
#endif
#ifndef reg_EBP
#define EBP (env->regs[R_EBP])
#endif
#ifndef reg_ESI
#define ESI (env->regs[R_ESI])
#endif
#ifndef reg_EDI
#define EDI (env->regs[R_EDI])
#endif
#define EIP  (env->eip)
#define DF  (env->df)

#define CC_SRC (env->cc_src)
#define CC_DST (env->cc_dst)
#define CC_OP  (env->cc_op)

/* float macros */
#define FT0    (env->ft0)
#define ST0    (env->fpregs[env->fpstt])
#define ST(n)  (env->fpregs[(env->fpstt + (n)) & 7])
#define ST1    ST(1)

#ifdef USE_FP_CONVERT
#define FP_CONVERT  (env->fp_convert)
#endif

#ifdef __alpha__
/* the symbols are considered non exported so a br immediate is generated */
#define __hidden __attribute__((visibility("hidden")))
#else
#define __hidden 
#endif

#ifdef __alpha__
/* Suggested by Richard Henderson. This will result in code like
        ldah $0,__op_param1($29)        !gprelhigh
        lda $0,__op_param1($0)          !gprellow
   We can then conveniently change $29 to $31 and adapt the offsets to
   emit the appropriate constant.  */
extern int __op_param1 __hidden;
extern int __op_param2 __hidden;
extern int __op_param3 __hidden;
#define PARAM1 ({ int _r; asm("" : "=r"(_r) : "0" (&__op_param1)); _r; })
#define PARAM2 ({ int _r; asm("" : "=r"(_r) : "0" (&__op_param2)); _r; })
#define PARAM3 ({ int _r; asm("" : "=r"(_r) : "0" (&__op_param3)); _r; })
#else
extern int __op_param1, __op_param2, __op_param3;
#define PARAM1 ((long)(&__op_param1))
#define PARAM2 ((long)(&__op_param2))
#define PARAM3 ((long)(&__op_param3))
#endif
extern int __op_jmp0, __op_jmp1;

#include "cpu-i386.h"
#include "exec.h"

typedef struct CCTable {
    int (*compute_all)(void); /* return all the flags */
    int (*compute_c)(void);  /* return the C flag */
} CCTable;

extern CCTable cc_table[];

void load_seg(int seg_reg, int selector, unsigned cur_eip);
void __hidden cpu_lock(void);
void __hidden cpu_unlock(void);
void raise_interrupt(int intno, int is_int, int error_code, 
                     unsigned int next_eip);
void raise_exception_err(int exception_index, int error_code);
void raise_exception(int exception_index);
void __hidden cpu_loop_exit(void);
void helper_fsave(uint8_t *ptr, int data32);
void helper_frstor(uint8_t *ptr, int data32);

void OPPROTO op_movl_eflags_T0(void);
void OPPROTO op_movl_T0_eflags(void);
void raise_interrupt(int intno, int is_int, int error_code, 
                     unsigned int next_eip);
void raise_exception_err(int exception_index, int error_code);
void raise_exception(int exception_index);
void helper_cpuid(void);
void helper_lsl(void);
void helper_lar(void);


#ifdef USE_X86LDOUBLE
/* use long double functions */
#define lrint lrintl
#define llrint llrintl
#define fabs fabsl
#define sin sinl
#define cos cosl
#define sqrt sqrtl
#define pow powl
#define log logl
#define tan tanl
#define atan2 atan2l
#define floor floorl
#define ceil ceill
#define rint rintl
#endif

extern int lrint(CPU86_LDouble x);
extern int64_t llrint(CPU86_LDouble x);
extern CPU86_LDouble fabs(CPU86_LDouble x);
extern CPU86_LDouble sin(CPU86_LDouble x);
extern CPU86_LDouble cos(CPU86_LDouble x);
extern CPU86_LDouble sqrt(CPU86_LDouble x);
extern CPU86_LDouble pow(CPU86_LDouble, CPU86_LDouble);
extern CPU86_LDouble log(CPU86_LDouble x);
extern CPU86_LDouble tan(CPU86_LDouble x);
extern CPU86_LDouble atan2(CPU86_LDouble, CPU86_LDouble);
extern CPU86_LDouble floor(CPU86_LDouble x);
extern CPU86_LDouble ceil(CPU86_LDouble x);
extern CPU86_LDouble rint(CPU86_LDouble x);

#define RC_MASK         0xc00
#define RC_NEAR		0x000
#define RC_DOWN		0x400
#define RC_UP		0x800
#define RC_CHOP		0xc00

#define MAXTAN 9223372036854775808.0

#ifdef USE_X86LDOUBLE

/* only for x86 */
typedef union {
    long double d;
    struct {
        unsigned long long lower;
        unsigned short upper;
    } l;
} CPU86_LDoubleU;

/* the following deal with x86 long double-precision numbers */
#define MAXEXPD 0x7fff
#define EXPBIAS 16383
#define EXPD(fp)	(fp.l.upper & 0x7fff)
#define SIGND(fp)	((fp.l.upper) & 0x8000)
#define MANTD(fp)       (fp.l.lower)
#define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7fff)) | EXPBIAS

#else

typedef union {
    double d;
#ifndef WORDS_BIGENDIAN
    struct {
        uint32_t lower;
        int32_t upper;
    } l;
#else
    struct {
        int32_t upper;
        uint32_t lower;
    } l;
#endif
    int64_t ll;
} CPU86_LDoubleU;

/* the following deal with IEEE double-precision numbers */
#define MAXEXPD 0x7ff
#define EXPBIAS 1023
#define EXPD(fp)	(((fp.l.upper) >> 20) & 0x7FF)
#define SIGND(fp)	((fp.l.upper) & 0x80000000)
#define MANTD(fp)	(fp.ll & ((1LL << 52) - 1))
#define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7ff << 20)) | (EXPBIAS << 20)
#endif

static inline void fpush(void)
{
    env->fpstt = (env->fpstt - 1) & 7;
    env->fptags[env->fpstt] = 0; /* validate stack entry */
}

static inline void fpop(void)
{
    env->fptags[env->fpstt] = 1; /* invvalidate stack entry */
    env->fpstt = (env->fpstt + 1) & 7;
}

#ifndef USE_X86LDOUBLE
static inline CPU86_LDouble helper_fldt(uint8_t *ptr)
{
    CPU86_LDoubleU temp;
    int upper, e;
    /* mantissa */
    upper = lduw(ptr + 8);
    /* XXX: handle overflow ? */
    e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */
    e |= (upper >> 4) & 0x800; /* sign */
    temp.ll = ((ldq(ptr) >> 11) & ((1LL << 52) - 1)) | ((uint64_t)e << 52);
    return temp.d;
}

static inline void helper_fstt(CPU86_LDouble f, uint8_t *ptr)
{
    CPU86_LDoubleU temp;
    int e;
    temp.d = f;
    /* mantissa */
    stq(ptr, (MANTD(temp) << 11) | (1LL << 63));
    /* exponent + sign */
    e = EXPD(temp) - EXPBIAS + 16383;
    e |= SIGND(temp) >> 16;
    stw(ptr + 8, e);
}
#endif

void helper_fldt_ST0_A0(void);
void helper_fstt_ST0_A0(void);
void helper_fbld_ST0_A0(void);
void helper_fbst_ST0_A0(void);
void helper_f2xm1(void);
void helper_fyl2x(void);
void helper_fptan(void);
void helper_fpatan(void);
void helper_fxtract(void);
void helper_fprem1(void);
void helper_fprem(void);
void helper_fyl2xp1(void);
void helper_fsqrt(void);
void helper_fsincos(void);
void helper_frndint(void);
void helper_fscale(void);
void helper_fsin(void);
void helper_fcos(void);
void helper_fxam_ST0(void);
void helper_fstenv(uint8_t *ptr, int data32);
void helper_fldenv(uint8_t *ptr, int data32);
void helper_fsave(uint8_t *ptr, int data32);
void helper_frstor(uint8_t *ptr, int data32);
Commit	Line	Data
3ef693a0 FB	1	/*
	2	* i386 execution defines
	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, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*/
7d13299d FB	20	typedef unsigned char uint8_t;
	21	typedef unsigned short uint16_t;
	22	typedef unsigned int uint32_t;
	23	typedef unsigned long long uint64_t;
	24
	25	typedef signed char int8_t;
	26	typedef signed short int16_t;
	27	typedef signed int int32_t;
	28	typedef signed long long int64_t;
	29
	30	#define bswap32(x) \
	31	({ \
	32	uint32_t __x = (x); \
	33	((uint32_t)( \
	34	(((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) \| \
	35	(((uint32_t)(__x) & (uint32_t)0x0000ff00UL) << 8) \| \
	36	(((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >> 8) \| \
	37	(((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) )); \
	38	})
	39
	40	#define NULL 0
	41	#include <fenv.h>
	42
	43	typedef struct FILE FILE;
	44	extern FILE *logfile;
	45	extern int loglevel;
	46	extern int fprintf(FILE , const char , ...);
6dbad63e	47	extern int printf(const char *, ...);
7d13299d FB	48
	49	#ifdef __i386__
	50	register unsigned int T0 asm("ebx");
	51	register unsigned int T1 asm("esi");
	52	register unsigned int A0 asm("edi");
	53	register struct CPUX86State *env asm("ebp");
	54	#endif
	55	#ifdef __powerpc__
04369ff2 FB	56	register unsigned int EAX asm("r16");
	57	register unsigned int ECX asm("r17");
	58	register unsigned int EDX asm("r18");
	59	register unsigned int EBX asm("r19");
	60	register unsigned int ESP asm("r20");
	61	register unsigned int EBP asm("r21");
	62	register unsigned int ESI asm("r22");
	63	register unsigned int EDI asm("r23");
7d13299d FB	64	register unsigned int T0 asm("r24");
	65	register unsigned int T1 asm("r25");
	66	register unsigned int A0 asm("r26");
	67	register struct CPUX86State *env asm("r27");
04369ff2	68	#define USE_INT_TO_FLOAT_HELPERS
d03cda59	69	#define BUGGY_GCC_DIV64
04369ff2 FB	70	#define reg_EAX
	71	#define reg_ECX
	72	#define reg_EDX
	73	#define reg_EBX
	74	#define reg_ESP
	75	#define reg_EBP
	76	#define reg_ESI
	77	#define reg_EDI
7d13299d FB	78	#endif
	79	#ifdef __arm__
	80	register unsigned int T0 asm("r4");
	81	register unsigned int T1 asm("r5");
	82	register unsigned int A0 asm("r6");
	83	register struct CPUX86State *env asm("r7");
	84	#endif
	85	#ifdef __mips__
	86	register unsigned int T0 asm("s0");
	87	register unsigned int T1 asm("s1");
	88	register unsigned int A0 asm("s2");
	89	register struct CPUX86State *env asm("s3");
	90	#endif
	91	#ifdef __sparc__
ae228531 FB	92	register unsigned int EAX asm("l0");
	93	register unsigned int ECX asm("l1");
	94	register unsigned int EDX asm("l2");
	95	register unsigned int EBX asm("l3");
	96	register unsigned int ESP asm("l4");
	97	register unsigned int EBP asm("l5");
	98	register unsigned int ESI asm("l6");
	99	register unsigned int EDI asm("l7");
	100	register unsigned int T0 asm("g1");
	101	register unsigned int T1 asm("g2");
	102	register unsigned int A0 asm("g3");
	103	register struct CPUX86State *env asm("g6");
d014c98c	104	#define USE_FP_CONVERT
ae228531 FB	105	#define reg_EAX
	106	#define reg_ECX
	107	#define reg_EDX
	108	#define reg_EBX
	109	#define reg_ESP
	110	#define reg_EBP
	111	#define reg_ESI
	112	#define reg_EDI
7d13299d	113	#endif
fb3e5849 FB	114	#ifdef __s390__
	115	register unsigned int T0 asm("r7");
	116	register unsigned int T1 asm("r8");
	117	register unsigned int A0 asm("r9");
	118	register struct CPUX86State *env asm("r10");
	119	#endif
d03cda59 FB	120	#ifdef __alpha__
	121	register unsigned int T0 asm("$9");
	122	register unsigned int T1 asm("$10");
	123	register unsigned int A0 asm("$11");
74c95119 FB	124	register unsigned int EAX asm("$12");
	125	register unsigned int ESP asm("$13");
	126	register unsigned int EBP asm("$14");
2f87c607 FB	127	/* Note $15 is the frame pointer, so anything in op-i386.c that would
2f87c607 FB	128	require a frame pointer, like alloca, would probably loose. */
74c95119 FB	129	register struct CPUX86State *env asm("$15");
	130	#define reg_EAX
	131	#define reg_ESP
	132	#define reg_EBP
d03cda59	133	#endif
0d330196 FB	134	#ifdef __ia64__
	135	register unsigned int T0 asm("r24");
	136	register unsigned int T1 asm("r25");
	137	register unsigned int A0 asm("r26");
	138	register struct CPUX86State *env asm("r27");
	139	#endif
7d13299d FB	140
	141	/* force GCC to generate only one epilog at the end of the function */
	142	#define FORCE_RET() asm volatile ("");
	143
	144	#ifndef OPPROTO
	145	#define OPPROTO
	146	#endif
	147
	148	#define xglue(x, y) x ## y
	149	#define glue(x, y) xglue(x, y)
	150
04369ff2	151	#ifndef reg_EAX
7d13299d	152	#define EAX (env->regs[R_EAX])
04369ff2 FB	153	#endif
04369ff2 FB	154	#ifndef reg_ECX
7d13299d	155	#define ECX (env->regs[R_ECX])
04369ff2 FB	156	#endif
04369ff2 FB	157	#ifndef reg_EDX
7d13299d	158	#define EDX (env->regs[R_EDX])
04369ff2 FB	159	#endif
04369ff2 FB	160	#ifndef reg_EBX
7d13299d	161	#define EBX (env->regs[R_EBX])
04369ff2 FB	162	#endif
04369ff2 FB	163	#ifndef reg_ESP
7d13299d	164	#define ESP (env->regs[R_ESP])
04369ff2 FB	165	#endif
04369ff2 FB	166	#ifndef reg_EBP
7d13299d	167	#define EBP (env->regs[R_EBP])
04369ff2 FB	168	#endif
04369ff2 FB	169	#ifndef reg_ESI
7d13299d	170	#define ESI (env->regs[R_ESI])
04369ff2 FB	171	#endif
04369ff2 FB	172	#ifndef reg_EDI
7d13299d	173	#define EDI (env->regs[R_EDI])
04369ff2	174	#endif
dab2ed99	175	#define EIP (env->eip)
7d13299d FB	176	#define DF (env->df)
	177
	178	#define CC_SRC (env->cc_src)
	179	#define CC_DST (env->cc_dst)
	180	#define CC_OP (env->cc_op)
	181
	182	/* float macros */
	183	#define FT0 (env->ft0)
	184	#define ST0 (env->fpregs[env->fpstt])
	185	#define ST(n) (env->fpregs[(env->fpstt + (n)) & 7])
	186	#define ST1 ST(1)
	187
d014c98c FB	188	#ifdef USE_FP_CONVERT
	189	#define FP_CONVERT (env->fp_convert)
	190	#endif
	191
3ec9c4fc FB	192	#ifdef __alpha__
	193	/* the symbols are considered non exported so a br immediate is generated */
	194	#define __hidden __attribute__((visibility("hidden")))
	195	#else
	196	#define __hidden
	197	#endif
	198
74c95119 FB	199	#ifdef __alpha__
	200	/* Suggested by Richard Henderson. This will result in code like
	201	ldah $0,__op_param1($29) !gprelhigh
	202	lda $0,__op_param1($0) !gprellow
	203	We can then conveniently change $29 to $31 and adapt the offsets to
	204	emit the appropriate constant. */
3ec9c4fc FB	205	extern int __op_param1 __hidden;
	206	extern int __op_param2 __hidden;
	207	extern int __op_param3 __hidden;
74c95119 FB	208	#define PARAM1 ({ int _r; asm("" : "=r"(_r) : "0" (&__op_param1)); _r; })
	209	#define PARAM2 ({ int _r; asm("" : "=r"(_r) : "0" (&__op_param2)); _r; })
	210	#define PARAM3 ({ int _r; asm("" : "=r"(_r) : "0" (&__op_param3)); _r; })
	211	#else
7d13299d FB	212	extern int __op_param1, __op_param2, __op_param3;
	213	#define PARAM1 ((long)(&__op_param1))
	214	#define PARAM2 ((long)(&__op_param2))
	215	#define PARAM3 ((long)(&__op_param3))
74c95119	216	#endif
d4e8164f	217	extern int __op_jmp0, __op_jmp1;
7d13299d FB	218
7d13299d FB	219	#include "cpu-i386.h"
d4e8164f	220	#include "exec.h"
7d13299d FB	221
	222	typedef struct CCTable {
	223	int (compute_all)(void); / return all the flags */
	224	int (compute_c)(void); / return the C flag */
	225	} CCTable;
	226
	227	extern CCTable cc_table[];
6dbad63e	228
a513fe19	229	void load_seg(int seg_reg, int selector, unsigned cur_eip);
3ec9c4fc FB	230	void __hidden cpu_lock(void);
3ec9c4fc FB	231	void __hidden cpu_unlock(void);
a513fe19 FB	232	void raise_interrupt(int intno, int is_int, int error_code,
a513fe19 FB	233	unsigned int next_eip);
455b7619	234	void raise_exception_err(int exception_index, int error_code);
9de5e440	235	void raise_exception(int exception_index);
3ec9c4fc	236	void __hidden cpu_loop_exit(void);
d0a1ffc9 FB	237	void helper_fsave(uint8_t *ptr, int data32);
d0a1ffc9 FB	238	void helper_frstor(uint8_t *ptr, int data32);
9de5e440 FB	239
	240	void OPPROTO op_movl_eflags_T0(void);
	241	void OPPROTO op_movl_T0_eflags(void);
3ec9c4fc FB	242	void raise_interrupt(int intno, int is_int, int error_code,
	243	unsigned int next_eip);
	244	void raise_exception_err(int exception_index, int error_code);
	245	void raise_exception(int exception_index);
	246	void helper_cpuid(void);
	247	void helper_lsl(void);
	248	void helper_lar(void);
	249
	250
	251	#ifdef USE_X86LDOUBLE
	252	/* use long double functions */
	253	#define lrint lrintl
	254	#define llrint llrintl
	255	#define fabs fabsl
	256	#define sin sinl
	257	#define cos cosl
	258	#define sqrt sqrtl
	259	#define pow powl
	260	#define log logl
	261	#define tan tanl
	262	#define atan2 atan2l
	263	#define floor floorl
	264	#define ceil ceill
	265	#define rint rintl
	266	#endif
	267
	268	extern int lrint(CPU86_LDouble x);
	269	extern int64_t llrint(CPU86_LDouble x);
	270	extern CPU86_LDouble fabs(CPU86_LDouble x);
	271	extern CPU86_LDouble sin(CPU86_LDouble x);
	272	extern CPU86_LDouble cos(CPU86_LDouble x);
	273	extern CPU86_LDouble sqrt(CPU86_LDouble x);
	274	extern CPU86_LDouble pow(CPU86_LDouble, CPU86_LDouble);
	275	extern CPU86_LDouble log(CPU86_LDouble x);
	276	extern CPU86_LDouble tan(CPU86_LDouble x);
	277	extern CPU86_LDouble atan2(CPU86_LDouble, CPU86_LDouble);
	278	extern CPU86_LDouble floor(CPU86_LDouble x);
	279	extern CPU86_LDouble ceil(CPU86_LDouble x);
	280	extern CPU86_LDouble rint(CPU86_LDouble x);
	281
	282	#define RC_MASK 0xc00
	283	#define RC_NEAR 0x000
	284	#define RC_DOWN 0x400
	285	#define RC_UP 0x800
	286	#define RC_CHOP 0xc00
	287
	288	#define MAXTAN 9223372036854775808.0
	289
	290	#ifdef USE_X86LDOUBLE
	291
	292	/* only for x86 */
	293	typedef union {
	294	long double d;
	295	struct {
	296	unsigned long long lower;
	297	unsigned short upper;
	298	} l;
	299	} CPU86_LDoubleU;
	300
	301	/* the following deal with x86 long double-precision numbers */
	302	#define MAXEXPD 0x7fff
	303	#define EXPBIAS 16383
	304	#define EXPD(fp) (fp.l.upper & 0x7fff)
	305	#define SIGND(fp) ((fp.l.upper) & 0x8000)
306	#define MANTD(fp) (fp.l.lower)
307	#define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7fff)) \| EXPBIAS
308
309	#else
310
311	typedef union {
312	double d;
313	#ifndef WORDS_BIGENDIAN
314	struct {
315	uint32_t lower;
316	int32_t upper;
317	} l;
318	#else
319	struct {
320	int32_t upper;
321	uint32_t lower;
322	} l;
323	#endif
324	int64_t ll;
325	} CPU86_LDoubleU;
326
327	/* the following deal with IEEE double-precision numbers */
328	#define MAXEXPD 0x7ff
329	#define EXPBIAS 1023
330	#define EXPD(fp) (((fp.l.upper) >> 20) & 0x7FF)
331	#define SIGND(fp) ((fp.l.upper) & 0x80000000)
332	#define MANTD(fp) (fp.ll & ((1LL << 52) - 1))
333	#define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7ff << 20)) \| (EXPBIAS << 20)
334	#endif
335
336	static inline void fpush(void)
337	{
338	env->fpstt = (env->fpstt - 1) & 7;
339	env->fptags[env->fpstt] = 0; /* validate stack entry */
340	}
341
342	static inline void fpop(void)
343	{
344	env->fptags[env->fpstt] = 1; /* invvalidate stack entry */
345	env->fpstt = (env->fpstt + 1) & 7;
346	}
347
348	#ifndef USE_X86LDOUBLE
349	static inline CPU86_LDouble helper_fldt(uint8_t *ptr)
350	{
351	CPU86_LDoubleU temp;
352	int upper, e;
353	/* mantissa */
354	upper = lduw(ptr + 8);
355	/* XXX: handle overflow ? */
356	e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */
357	e \|= (upper >> 4) & 0x800; /* sign */
358	temp.ll = ((ldq(ptr) >> 11) & ((1LL << 52) - 1)) \| ((uint64_t)e << 52);
359	return temp.d;
360	}
361
362	static inline void helper_fstt(CPU86_LDouble f, uint8_t *ptr)
363	{
364	CPU86_LDoubleU temp;
365	int e;
366	temp.d = f;
367	/* mantissa */
368	stq(ptr, (MANTD(temp) << 11) \| (1LL << 63));
369	/* exponent + sign */
370	e = EXPD(temp) - EXPBIAS + 16383;
371	e \|= SIGND(temp) >> 16;
372	stw(ptr + 8, e);
373	}
374	#endif
375
376	void helper_fldt_ST0_A0(void);
377	void helper_fstt_ST0_A0(void);
378	void helper_fbld_ST0_A0(void);
379	void helper_fbst_ST0_A0(void);
380	void helper_f2xm1(void);
381	void helper_fyl2x(void);
382	void helper_fptan(void);
383	void helper_fpatan(void);
384	void helper_fxtract(void);
385	void helper_fprem1(void);
386	void helper_fprem(void);
387	void helper_fyl2xp1(void);
388	void helper_fsqrt(void);
389	void helper_fsincos(void);
390	void helper_frndint(void);
391	void helper_fscale(void);
392	void helper_fsin(void);
393	void helper_fcos(void);
394	void helper_fxam_ST0(void);
395	void helper_fstenv(uint8_t *ptr, int data32);
396	void helper_fldenv(uint8_t *ptr, int data32);
397	void helper_fsave(uint8_t *ptr, int data32);
398	void helper_frstor(uint8_t *ptr, int data32);
399