2 * i386 execution defines
4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
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
21 #include "dyngen-exec.h"
23 /* XXX: factorize this mess */
25 #define TARGET_LONG_BITS 64
27 #define TARGET_LONG_BITS 32
32 /* at least 4 register variables are defined */
33 register struct CPUX86State
*env
asm(AREG0
);
35 #ifndef CPU_NO_GLOBAL_REGS
37 #if TARGET_LONG_BITS > HOST_LONG_BITS
39 /* no registers can be used */
46 /* XXX: use unsigned long instead of target_ulong - better code will
47 be generated for 64 bit CPUs */
48 register target_ulong T0
asm(AREG1
);
49 register target_ulong T1
asm(AREG2
);
50 register target_ulong T2
asm(AREG3
);
52 #endif /* ! (TARGET_LONG_BITS > HOST_LONG_BITS) */
54 #endif /* ! CPU_NO_GLOBAL_REGS */
62 #define EAX (env->regs[R_EAX])
65 #define ECX (env->regs[R_ECX])
68 #define EDX (env->regs[R_EDX])
71 #define EBX (env->regs[R_EBX])
74 #define ESP (env->regs[R_ESP])
77 #define EBP (env->regs[R_EBP])
80 #define ESI (env->regs[R_ESI])
83 #define EDI (env->regs[R_EDI])
85 #define EIP (env->eip)
88 #define CC_SRC (env->cc_src)
89 #define CC_DST (env->cc_dst)
90 #define CC_OP (env->cc_op)
93 #define FT0 (env->ft0)
94 #define ST0 (env->fpregs[env->fpstt].d)
95 #define ST(n) (env->fpregs[(env->fpstt + (n)) & 7].d)
101 void cpu_x86_update_cr0(CPUX86State
*env
, uint32_t new_cr0
);
102 void cpu_x86_update_cr3(CPUX86State
*env
, target_ulong new_cr3
);
103 void cpu_x86_update_cr4(CPUX86State
*env
, uint32_t new_cr4
);
104 void cpu_x86_flush_tlb(CPUX86State
*env
, target_ulong addr
);
105 int cpu_x86_handle_mmu_fault(CPUX86State
*env
, target_ulong addr
,
106 int is_write
, int mmu_idx
, int is_softmmu
);
107 void tlb_fill(target_ulong addr
, int is_write
, int mmu_idx
,
109 void __hidden
cpu_lock(void);
110 void __hidden
cpu_unlock(void);
111 void do_interrupt(int intno
, int is_int
, int error_code
,
112 target_ulong next_eip
, int is_hw
);
113 void do_interrupt_user(int intno
, int is_int
, int error_code
,
114 target_ulong next_eip
);
115 void raise_interrupt(int intno
, int is_int
, int error_code
,
116 int next_eip_addend
);
117 void raise_exception_err(int exception_index
, int error_code
);
118 void raise_exception(int exception_index
);
119 void do_smm_enter(void);
120 void __hidden
cpu_loop_exit(void);
122 void OPPROTO
op_movl_eflags_T0(void);
123 void OPPROTO
op_movl_T0_eflags(void);
125 /* n must be a constant to be efficient */
126 static inline target_long
lshift(target_long x
, int n
)
136 static inline void svm_check_intercept(uint32_t type
)
138 helper_svm_check_intercept_param(type
, 0);
141 #if !defined(CONFIG_USER_ONLY)
143 #include "softmmu_exec.h"
145 #endif /* !defined(CONFIG_USER_ONLY) */
147 #ifdef USE_X86LDOUBLE
148 /* use long double functions */
149 #define floatx_to_int32 floatx80_to_int32
150 #define floatx_to_int64 floatx80_to_int64
151 #define floatx_to_int32_round_to_zero floatx80_to_int32_round_to_zero
152 #define floatx_to_int64_round_to_zero floatx80_to_int64_round_to_zero
153 #define int32_to_floatx int32_to_floatx80
154 #define int64_to_floatx int64_to_floatx80
155 #define float32_to_floatx float32_to_floatx80
156 #define float64_to_floatx float64_to_floatx80
157 #define floatx_to_float32 floatx80_to_float32
158 #define floatx_to_float64 floatx80_to_float64
159 #define floatx_abs floatx80_abs
160 #define floatx_chs floatx80_chs
161 #define floatx_round_to_int floatx80_round_to_int
162 #define floatx_compare floatx80_compare
163 #define floatx_compare_quiet floatx80_compare_quiet
175 #define floatx_to_int32 float64_to_int32
176 #define floatx_to_int64 float64_to_int64
177 #define floatx_to_int32_round_to_zero float64_to_int32_round_to_zero
178 #define floatx_to_int64_round_to_zero float64_to_int64_round_to_zero
179 #define int32_to_floatx int32_to_float64
180 #define int64_to_floatx int64_to_float64
181 #define float32_to_floatx float32_to_float64
182 #define float64_to_floatx(x, e) (x)
183 #define floatx_to_float32 float64_to_float32
184 #define floatx_to_float64(x, e) (x)
185 #define floatx_abs float64_abs
186 #define floatx_chs float64_chs
187 #define floatx_round_to_int float64_round_to_int
188 #define floatx_compare float64_compare
189 #define floatx_compare_quiet float64_compare_quiet
192 extern CPU86_LDouble
sin(CPU86_LDouble x
);
193 extern CPU86_LDouble
cos(CPU86_LDouble x
);
194 extern CPU86_LDouble
sqrt(CPU86_LDouble x
);
195 extern CPU86_LDouble
pow(CPU86_LDouble
, CPU86_LDouble
);
196 extern CPU86_LDouble
log(CPU86_LDouble x
);
197 extern CPU86_LDouble
tan(CPU86_LDouble x
);
198 extern CPU86_LDouble
atan2(CPU86_LDouble
, CPU86_LDouble
);
199 extern CPU86_LDouble
floor(CPU86_LDouble x
);
200 extern CPU86_LDouble
ceil(CPU86_LDouble x
);
202 #define RC_MASK 0xc00
203 #define RC_NEAR 0x000
204 #define RC_DOWN 0x400
206 #define RC_CHOP 0xc00
208 #define MAXTAN 9223372036854775808.0
210 #ifdef USE_X86LDOUBLE
216 unsigned long long lower
;
217 unsigned short upper
;
221 /* the following deal with x86 long double-precision numbers */
222 #define MAXEXPD 0x7fff
223 #define EXPBIAS 16383
224 #define EXPD(fp) (fp.l.upper & 0x7fff)
225 #define SIGND(fp) ((fp.l.upper) & 0x8000)
226 #define MANTD(fp) (fp.l.lower)
227 #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7fff)) | EXPBIAS
231 /* NOTE: arm is horrible as double 32 bit words are stored in big endian ! */
234 #if !defined(WORDS_BIGENDIAN) && !defined(__arm__)
250 /* the following deal with IEEE double-precision numbers */
251 #define MAXEXPD 0x7ff
253 #define EXPD(fp) (((fp.l.upper) >> 20) & 0x7FF)
254 #define SIGND(fp) ((fp.l.upper) & 0x80000000)
256 #define MANTD(fp) (fp.l.lower | ((uint64_t)(fp.l.upper & ((1 << 20) - 1)) << 32))
258 #define MANTD(fp) (fp.ll & ((1LL << 52) - 1))
260 #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7ff << 20)) | (EXPBIAS << 20)
263 static inline void fpush(void)
265 env
->fpstt
= (env
->fpstt
- 1) & 7;
266 env
->fptags
[env
->fpstt
] = 0; /* validate stack entry */
269 static inline void fpop(void)
271 env
->fptags
[env
->fpstt
] = 1; /* invvalidate stack entry */
272 env
->fpstt
= (env
->fpstt
+ 1) & 7;
275 #ifndef USE_X86LDOUBLE
276 static inline CPU86_LDouble
helper_fldt(target_ulong ptr
)
283 upper
= lduw(ptr
+ 8);
284 /* XXX: handle overflow ? */
285 e
= (upper
& 0x7fff) - 16383 + EXPBIAS
; /* exponent */
286 e
|= (upper
>> 4) & 0x800; /* sign */
287 ll
= (ldq(ptr
) >> 11) & ((1LL << 52) - 1);
289 temp
.l
.upper
= (e
<< 20) | (ll
>> 32);
292 temp
.ll
= ll
| ((uint64_t)e
<< 52);
297 static inline void helper_fstt(CPU86_LDouble f
, target_ulong ptr
)
304 stq(ptr
, (MANTD(temp
) << 11) | (1LL << 63));
305 /* exponent + sign */
306 e
= EXPD(temp
) - EXPBIAS
+ 16383;
307 e
|= SIGND(temp
) >> 16;
312 /* we use memory access macros */
314 static inline CPU86_LDouble
helper_fldt(target_ulong ptr
)
318 temp
.l
.lower
= ldq(ptr
);
319 temp
.l
.upper
= lduw(ptr
+ 8);
323 static inline void helper_fstt(CPU86_LDouble f
, target_ulong ptr
)
328 stq(ptr
, temp
.l
.lower
);
329 stw(ptr
+ 8, temp
.l
.upper
);
332 #endif /* USE_X86LDOUBLE */
334 #define FPUS_IE (1 << 0)
335 #define FPUS_DE (1 << 1)
336 #define FPUS_ZE (1 << 2)
337 #define FPUS_OE (1 << 3)
338 #define FPUS_UE (1 << 4)
339 #define FPUS_PE (1 << 5)
340 #define FPUS_SF (1 << 6)
341 #define FPUS_SE (1 << 7)
342 #define FPUS_B (1 << 15)
346 extern const CPU86_LDouble f15rk
[7];
348 void fpu_raise_exception(void);
349 void restore_native_fp_state(CPUState
*env
);
350 void save_native_fp_state(CPUState
*env
);
352 extern const uint8_t parity_table
[256];
353 extern const uint8_t rclw_table
[32];
354 extern const uint8_t rclb_table
[32];
356 static inline uint32_t compute_eflags(void)
358 return env
->eflags
| cc_table
[CC_OP
].compute_all() | (DF
& DF_MASK
);
361 /* NOTE: CC_OP must be modified manually to CC_OP_EFLAGS */
362 static inline void load_eflags(int eflags
, int update_mask
)
364 CC_SRC
= eflags
& (CC_O
| CC_S
| CC_Z
| CC_A
| CC_P
| CC_C
);
365 DF
= 1 - (2 * ((eflags
>> 10) & 1));
366 env
->eflags
= (env
->eflags
& ~update_mask
) |
367 (eflags
& update_mask
);
370 static inline void env_to_regs(void)
373 EAX
= env
->regs
[R_EAX
];
376 ECX
= env
->regs
[R_ECX
];
379 EDX
= env
->regs
[R_EDX
];
382 EBX
= env
->regs
[R_EBX
];
385 ESP
= env
->regs
[R_ESP
];
388 EBP
= env
->regs
[R_EBP
];
391 ESI
= env
->regs
[R_ESI
];
394 EDI
= env
->regs
[R_EDI
];
398 static inline void regs_to_env(void)
401 env
->regs
[R_EAX
] = EAX
;
404 env
->regs
[R_ECX
] = ECX
;
407 env
->regs
[R_EDX
] = EDX
;
410 env
->regs
[R_EBX
] = EBX
;
413 env
->regs
[R_ESP
] = ESP
;
416 env
->regs
[R_EBP
] = EBP
;
419 env
->regs
[R_ESI
] = ESI
;
422 env
->regs
[R_EDI
] = EDI
;
426 static inline int cpu_halted(CPUState
*env
) {
427 /* handle exit of HALTED state */
428 if (!(env
->hflags
& HF_HALTED_MASK
))
430 /* disable halt condition */
431 if (((env
->interrupt_request
& CPU_INTERRUPT_HARD
) &&
432 (env
->eflags
& IF_MASK
)) ||
433 (env
->interrupt_request
& CPU_INTERRUPT_NMI
)) {
434 env
->hflags
&= ~HF_HALTED_MASK
;