]>
Commit | Line | Data |
---|---|---|
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, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | #include "config.h" | |
20 | #include "dyngen-exec.h" | |
21 | ||
22 | /* XXX: factorize this mess */ | |
23 | #ifdef TARGET_X86_64 | |
24 | #define TARGET_LONG_BITS 64 | |
25 | #else | |
26 | #define TARGET_LONG_BITS 32 | |
27 | #endif | |
28 | ||
29 | #include "cpu-defs.h" | |
30 | ||
31 | register struct CPUX86State *env asm(AREG0); | |
32 | ||
33 | #include "qemu-common.h" | |
34 | #include "qemu-log.h" | |
35 | ||
36 | #undef EAX | |
37 | #define EAX (env->regs[R_EAX]) | |
38 | #undef ECX | |
39 | #define ECX (env->regs[R_ECX]) | |
40 | #undef EDX | |
41 | #define EDX (env->regs[R_EDX]) | |
42 | #undef EBX | |
43 | #define EBX (env->regs[R_EBX]) | |
44 | #undef ESP | |
45 | #define ESP (env->regs[R_ESP]) | |
46 | #undef EBP | |
47 | #define EBP (env->regs[R_EBP]) | |
48 | #undef ESI | |
49 | #define ESI (env->regs[R_ESI]) | |
50 | #undef EDI | |
51 | #define EDI (env->regs[R_EDI]) | |
52 | #undef EIP | |
53 | #define EIP (env->eip) | |
54 | #define DF (env->df) | |
55 | ||
56 | #define CC_SRC (env->cc_src) | |
57 | #define CC_DST (env->cc_dst) | |
58 | #define CC_OP (env->cc_op) | |
59 | ||
60 | /* float macros */ | |
61 | #define FT0 (env->ft0) | |
62 | #define ST0 (env->fpregs[env->fpstt].d) | |
63 | #define ST(n) (env->fpregs[(env->fpstt + (n)) & 7].d) | |
64 | #define ST1 ST(1) | |
65 | ||
66 | #include "cpu.h" | |
67 | #include "exec-all.h" | |
68 | ||
69 | /* op_helper.c */ | |
70 | void do_interrupt(int intno, int is_int, int error_code, | |
71 | target_ulong next_eip, int is_hw); | |
72 | void do_interrupt_user(int intno, int is_int, int error_code, | |
73 | target_ulong next_eip); | |
74 | void QEMU_NORETURN raise_exception_err(int exception_index, int error_code); | |
75 | void QEMU_NORETURN raise_exception(int exception_index); | |
76 | void QEMU_NORETURN raise_exception_env(int exception_index, CPUState *nenv); | |
77 | void do_smm_enter(void); | |
78 | ||
79 | /* n must be a constant to be efficient */ | |
80 | static inline target_long lshift(target_long x, int n) | |
81 | { | |
82 | if (n >= 0) | |
83 | return x << n; | |
84 | else | |
85 | return x >> (-n); | |
86 | } | |
87 | ||
88 | #include "helper.h" | |
89 | ||
90 | static inline void svm_check_intercept(uint32_t type) | |
91 | { | |
92 | helper_svm_check_intercept_param(type, 0); | |
93 | } | |
94 | ||
95 | #if !defined(CONFIG_USER_ONLY) | |
96 | ||
97 | #include "softmmu_exec.h" | |
98 | ||
99 | #endif /* !defined(CONFIG_USER_ONLY) */ | |
100 | ||
101 | #ifdef USE_X86LDOUBLE | |
102 | /* use long double functions */ | |
103 | #define floatx_to_int32 floatx80_to_int32 | |
104 | #define floatx_to_int64 floatx80_to_int64 | |
105 | #define floatx_to_int32_round_to_zero floatx80_to_int32_round_to_zero | |
106 | #define floatx_to_int64_round_to_zero floatx80_to_int64_round_to_zero | |
107 | #define int32_to_floatx int32_to_floatx80 | |
108 | #define int64_to_floatx int64_to_floatx80 | |
109 | #define float32_to_floatx float32_to_floatx80 | |
110 | #define float64_to_floatx float64_to_floatx80 | |
111 | #define floatx_to_float32 floatx80_to_float32 | |
112 | #define floatx_to_float64 floatx80_to_float64 | |
113 | #define floatx_add floatx80_add | |
114 | #define floatx_div floatx80_div | |
115 | #define floatx_mul floatx80_mul | |
116 | #define floatx_sub floatx80_sub | |
117 | #define floatx_abs floatx80_abs | |
118 | #define floatx_chs floatx80_chs | |
119 | #define floatx_scalbn floatx80_scalbn | |
120 | #define floatx_round_to_int floatx80_round_to_int | |
121 | #define floatx_compare floatx80_compare | |
122 | #define floatx_compare_quiet floatx80_compare_quiet | |
123 | #define floatx_is_any_nan floatx80_is_any_nan | |
124 | #define floatx_is_zero floatx80_is_zero | |
125 | #else | |
126 | #define floatx_to_int32 float64_to_int32 | |
127 | #define floatx_to_int64 float64_to_int64 | |
128 | #define floatx_to_int32_round_to_zero float64_to_int32_round_to_zero | |
129 | #define floatx_to_int64_round_to_zero float64_to_int64_round_to_zero | |
130 | #define int32_to_floatx int32_to_float64 | |
131 | #define int64_to_floatx int64_to_float64 | |
132 | #define float32_to_floatx float32_to_float64 | |
133 | #define float64_to_floatx(x, e) (x) | |
134 | #define floatx_to_float32 float64_to_float32 | |
135 | #define floatx_to_float64(x, e) (x) | |
136 | #define floatx_add float64_add | |
137 | #define floatx_div float64_div | |
138 | #define floatx_mul float64_mul | |
139 | #define floatx_sub float64_sub | |
140 | #define floatx_abs float64_abs | |
141 | #define floatx_chs float64_chs | |
142 | #define floatx_scalbn float64_scalbn | |
143 | #define floatx_round_to_int float64_round_to_int | |
144 | #define floatx_compare float64_compare | |
145 | #define floatx_compare_quiet float64_compare_quiet | |
146 | #define floatx_is_any_nan float64_is_any_nan | |
147 | #define floatx_is_zero float64_is_zero | |
148 | #endif | |
149 | ||
150 | #define RC_MASK 0xc00 | |
151 | #define RC_NEAR 0x000 | |
152 | #define RC_DOWN 0x400 | |
153 | #define RC_UP 0x800 | |
154 | #define RC_CHOP 0xc00 | |
155 | ||
156 | #define MAXTAN 9223372036854775808.0 | |
157 | ||
158 | #ifdef USE_X86LDOUBLE | |
159 | ||
160 | /* only for x86 */ | |
161 | typedef CPU_LDoubleU CPU86_LDoubleU; | |
162 | ||
163 | /* the following deal with x86 long double-precision numbers */ | |
164 | #define MAXEXPD 0x7fff | |
165 | #define EXPBIAS 16383 | |
166 | #define EXPD(fp) (fp.l.upper & 0x7fff) | |
167 | #define SIGND(fp) ((fp.l.upper) & 0x8000) | |
168 | #define MANTD(fp) (fp.l.lower) | |
169 | #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7fff)) | EXPBIAS | |
170 | ||
171 | #else | |
172 | ||
173 | typedef CPU_DoubleU CPU86_LDoubleU; | |
174 | ||
175 | /* the following deal with IEEE double-precision numbers */ | |
176 | #define MAXEXPD 0x7ff | |
177 | #define EXPBIAS 1023 | |
178 | #define EXPD(fp) (((fp.l.upper) >> 20) & 0x7FF) | |
179 | #define SIGND(fp) ((fp.l.upper) & 0x80000000) | |
180 | #ifdef __arm__ | |
181 | #define MANTD(fp) (fp.l.lower | ((uint64_t)(fp.l.upper & ((1 << 20) - 1)) << 32)) | |
182 | #else | |
183 | #define MANTD(fp) (fp.ll & ((1LL << 52) - 1)) | |
184 | #endif | |
185 | #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7ff << 20)) | (EXPBIAS << 20) | |
186 | #endif | |
187 | ||
188 | static inline void fpush(void) | |
189 | { | |
190 | env->fpstt = (env->fpstt - 1) & 7; | |
191 | env->fptags[env->fpstt] = 0; /* validate stack entry */ | |
192 | } | |
193 | ||
194 | static inline void fpop(void) | |
195 | { | |
196 | env->fptags[env->fpstt] = 1; /* invvalidate stack entry */ | |
197 | env->fpstt = (env->fpstt + 1) & 7; | |
198 | } | |
199 | ||
200 | #ifndef USE_X86LDOUBLE | |
201 | static inline CPU86_LDouble helper_fldt(target_ulong ptr) | |
202 | { | |
203 | CPU86_LDoubleU temp; | |
204 | int upper, e; | |
205 | uint64_t ll; | |
206 | ||
207 | /* mantissa */ | |
208 | upper = lduw(ptr + 8); | |
209 | /* XXX: handle overflow ? */ | |
210 | e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */ | |
211 | e |= (upper >> 4) & 0x800; /* sign */ | |
212 | ll = (ldq(ptr) >> 11) & ((1LL << 52) - 1); | |
213 | #ifdef __arm__ | |
214 | temp.l.upper = (e << 20) | (ll >> 32); | |
215 | temp.l.lower = ll; | |
216 | #else | |
217 | temp.ll = ll | ((uint64_t)e << 52); | |
218 | #endif | |
219 | return temp.d; | |
220 | } | |
221 | ||
222 | static inline void helper_fstt(CPU86_LDouble f, target_ulong ptr) | |
223 | { | |
224 | CPU86_LDoubleU temp; | |
225 | int e; | |
226 | ||
227 | temp.d = f; | |
228 | /* mantissa */ | |
229 | stq(ptr, (MANTD(temp) << 11) | (1LL << 63)); | |
230 | /* exponent + sign */ | |
231 | e = EXPD(temp) - EXPBIAS + 16383; | |
232 | e |= SIGND(temp) >> 16; | |
233 | stw(ptr + 8, e); | |
234 | } | |
235 | #else | |
236 | ||
237 | /* we use memory access macros */ | |
238 | ||
239 | static inline CPU86_LDouble helper_fldt(target_ulong ptr) | |
240 | { | |
241 | CPU86_LDoubleU temp; | |
242 | ||
243 | temp.l.lower = ldq(ptr); | |
244 | temp.l.upper = lduw(ptr + 8); | |
245 | return temp.d; | |
246 | } | |
247 | ||
248 | static inline void helper_fstt(CPU86_LDouble f, target_ulong ptr) | |
249 | { | |
250 | CPU86_LDoubleU temp; | |
251 | ||
252 | temp.d = f; | |
253 | stq(ptr, temp.l.lower); | |
254 | stw(ptr + 8, temp.l.upper); | |
255 | } | |
256 | ||
257 | #endif /* USE_X86LDOUBLE */ | |
258 | ||
259 | #define FPUS_IE (1 << 0) | |
260 | #define FPUS_DE (1 << 1) | |
261 | #define FPUS_ZE (1 << 2) | |
262 | #define FPUS_OE (1 << 3) | |
263 | #define FPUS_UE (1 << 4) | |
264 | #define FPUS_PE (1 << 5) | |
265 | #define FPUS_SF (1 << 6) | |
266 | #define FPUS_SE (1 << 7) | |
267 | #define FPUS_B (1 << 15) | |
268 | ||
269 | #define FPUC_EM 0x3f | |
270 | ||
271 | static inline uint32_t compute_eflags(void) | |
272 | { | |
273 | return env->eflags | helper_cc_compute_all(CC_OP) | (DF & DF_MASK); | |
274 | } | |
275 | ||
276 | /* NOTE: CC_OP must be modified manually to CC_OP_EFLAGS */ | |
277 | static inline void load_eflags(int eflags, int update_mask) | |
278 | { | |
279 | CC_SRC = eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C); | |
280 | DF = 1 - (2 * ((eflags >> 10) & 1)); | |
281 | env->eflags = (env->eflags & ~update_mask) | | |
282 | (eflags & update_mask) | 0x2; | |
283 | } | |
284 | ||
285 | static inline int cpu_has_work(CPUState *env) | |
286 | { | |
287 | return ((env->interrupt_request & CPU_INTERRUPT_HARD) && | |
288 | (env->eflags & IF_MASK)) || | |
289 | (env->interrupt_request & (CPU_INTERRUPT_NMI | | |
290 | CPU_INTERRUPT_INIT | | |
291 | CPU_INTERRUPT_SIPI | | |
292 | CPU_INTERRUPT_MCE)); | |
293 | } | |
294 | ||
295 | /* load efer and update the corresponding hflags. XXX: do consistency | |
296 | checks with cpuid bits ? */ | |
297 | static inline void cpu_load_efer(CPUState *env, uint64_t val) | |
298 | { | |
299 | env->efer = val; | |
300 | env->hflags &= ~(HF_LMA_MASK | HF_SVME_MASK); | |
301 | if (env->efer & MSR_EFER_LMA) | |
302 | env->hflags |= HF_LMA_MASK; | |
303 | if (env->efer & MSR_EFER_SVME) | |
304 | env->hflags |= HF_SVME_MASK; | |
305 | } | |
306 | ||
307 | static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) | |
308 | { | |
309 | env->eip = tb->pc - tb->cs_base; | |
310 | } | |
311 |