]> git.proxmox.com Git - qemu.git/blob - target-i386/op_helper.c
projects / qemu.git / blob
? search:


217916a05cd8b5b3ebbd120cc003520cbc709953
[qemu.git] / target-i386 / op_helper.c
1 /*
2 * i386 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, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA
19 */
20 #define CPU_NO_GLOBAL_REGS
21 #include "exec.h"
22 #include "exec-all.h"
23 #include "host-utils.h"
24
25 //#define DEBUG_PCALL
26
27
28 #ifdef DEBUG_PCALL
29 # define LOG_PCALL(...) qemu_log_mask(CPU_LOG_PCALL, ## __VA_ARGS__)
30 # define LOG_PCALL_STATE(env) \
31 log_cpu_state_mask(CPU_LOG_PCALL, (env), X86_DUMP_CCOP)
32 #else
33 # define LOG_PCALL(...) do { } while (0)
34 # define LOG_PCALL_STATE(env) do { } while (0)
35 #endif
36
37
38 #if 0
39 #define raise_exception_err(a, b)\
40 do {\
41 qemu_log("raise_exception line=%d\n", __LINE__);\
42 (raise_exception_err)(a, b);\
43 } while (0)
44 #endif
45
46 static const uint8_t parity_table[256] = {
47 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
48 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
49 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
50 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
51 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
52 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
53 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
54 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
55 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
56 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
57 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
58 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
59 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
60 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
61 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
62 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
63 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
64 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
65 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
66 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
67 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
68 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
69 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
70 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
71 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
72 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
73 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
74 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
75 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
76 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
77 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
78 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
79 };
80
81 /* modulo 17 table */
82 static const uint8_t rclw_table[32] = {
83 0, 1, 2, 3, 4, 5, 6, 7,
84 8, 9,10,11,12,13,14,15,
85 16, 0, 1, 2, 3, 4, 5, 6,
86 7, 8, 9,10,11,12,13,14,
87 };
88
89 /* modulo 9 table */
90 static const uint8_t rclb_table[32] = {
91 0, 1, 2, 3, 4, 5, 6, 7,
92 8, 0, 1, 2, 3, 4, 5, 6,
93 7, 8, 0, 1, 2, 3, 4, 5,
94 6, 7, 8, 0, 1, 2, 3, 4,
95 };
96
97 static const CPU86_LDouble f15rk[7] =
98 {
99 0.00000000000000000000L,
100 1.00000000000000000000L,
101 3.14159265358979323851L, /*pi*/
102 0.30102999566398119523L, /*lg2*/
103 0.69314718055994530943L, /*ln2*/
104 1.44269504088896340739L, /*l2e*/
105 3.32192809488736234781L, /*l2t*/
106 };
107
108 /* broken thread support */
109
110 static spinlock_t global_cpu_lock = SPIN_LOCK_UNLOCKED;
111
112 void helper_lock(void)
113 {
114 spin_lock(&global_cpu_lock);
115 }
116
117 void helper_unlock(void)
118 {
119 spin_unlock(&global_cpu_lock);
120 }
121
122 void helper_write_eflags(target_ulong t0, uint32_t update_mask)
123 {
124 load_eflags(t0, update_mask);
125 }
126
127 target_ulong helper_read_eflags(void)
128 {
129 uint32_t eflags;
130 eflags = helper_cc_compute_all(CC_OP);
131 eflags |= (DF & DF_MASK);
132 eflags |= env->eflags & ~(VM_MASK | RF_MASK);
133 return eflags;
134 }
135
136 /* return non zero if error */
137 static inline int load_segment(uint32_t *e1_ptr, uint32_t *e2_ptr,
138 int selector)
139 {
140 SegmentCache *dt;
141 int index;
142 target_ulong ptr;
143
144 if (selector & 0x4)
145 dt = &env->ldt;
146 else
147 dt = &env->gdt;
148 index = selector & ~7;
149 if ((index + 7) > dt->limit)
150 return -1;
151 ptr = dt->base + index;
152 *e1_ptr = ldl_kernel(ptr);
153 *e2_ptr = ldl_kernel(ptr + 4);
154 return 0;
155 }
156
157 static inline unsigned int get_seg_limit(uint32_t e1, uint32_t e2)
158 {
159 unsigned int limit;
160 limit = (e1 & 0xffff) | (e2 & 0x000f0000);
161 if (e2 & DESC_G_MASK)
162 limit = (limit << 12) | 0xfff;
163 return limit;
164 }
165
166 static inline uint32_t get_seg_base(uint32_t e1, uint32_t e2)
167 {
168 return ((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000));
169 }
170
171 static inline void load_seg_cache_raw_dt(SegmentCache *sc, uint32_t e1, uint32_t e2)
172 {
173 sc->base = get_seg_base(e1, e2);
174 sc->limit = get_seg_limit(e1, e2);
175 sc->flags = e2;
176 }
177
178 /* init the segment cache in vm86 mode. */
179 static inline void load_seg_vm(int seg, int selector)
180 {
181 selector &= 0xffff;
182 cpu_x86_load_seg_cache(env, seg, selector,
183 (selector << 4), 0xffff, 0);
184 }
185
186 static inline void get_ss_esp_from_tss(uint32_t *ss_ptr,
187 uint32_t *esp_ptr, int dpl)
188 {
189 int type, index, shift;
190
191 #if 0
192 {
193 int i;
194 printf("TR: base=%p limit=%x\n", env->tr.base, env->tr.limit);
195 for(i=0;i<env->tr.limit;i++) {
196 printf("%02x ", env->tr.base[i]);
197 if ((i & 7) == 7) printf("\n");
198 }
199 printf("\n");
200 }
201 #endif
202
203 if (!(env->tr.flags & DESC_P_MASK))
204 cpu_abort(env, "invalid tss");
205 type = (env->tr.flags >> DESC_TYPE_SHIFT) & 0xf;
206 if ((type & 7) != 1)
207 cpu_abort(env, "invalid tss type");
208 shift = type >> 3;
209 index = (dpl * 4 + 2) << shift;
210 if (index + (4 << shift) - 1 > env->tr.limit)
211 raise_exception_err(EXCP0A_TSS, env->tr.selector & 0xfffc);
212 if (shift == 0) {
213 *esp_ptr = lduw_kernel(env->tr.base + index);
214 *ss_ptr = lduw_kernel(env->tr.base + index + 2);
215 } else {
216 *esp_ptr = ldl_kernel(env->tr.base + index);
217 *ss_ptr = lduw_kernel(env->tr.base + index + 4);
218 }
219 }
220
221 /* XXX: merge with load_seg() */
222 static void tss_load_seg(int seg_reg, int selector)
223 {
224 uint32_t e1, e2;
225 int rpl, dpl, cpl;
226
227 if ((selector & 0xfffc) != 0) {
228 if (load_segment(&e1, &e2, selector) != 0)
229 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
230 if (!(e2 & DESC_S_MASK))
231 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
232 rpl = selector & 3;
233 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
234 cpl = env->hflags & HF_CPL_MASK;
235 if (seg_reg == R_CS) {
236 if (!(e2 & DESC_CS_MASK))
237 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
238 /* XXX: is it correct ? */
239 if (dpl != rpl)
240 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
241 if ((e2 & DESC_C_MASK) && dpl > rpl)
242 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
243 } else if (seg_reg == R_SS) {
244 /* SS must be writable data */
245 if ((e2 & DESC_CS_MASK) || !(e2 & DESC_W_MASK))
246 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
247 if (dpl != cpl || dpl != rpl)
248 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
249 } else {
250 /* not readable code */
251 if ((e2 & DESC_CS_MASK) && !(e2 & DESC_R_MASK))
252 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
253 /* if data or non conforming code, checks the rights */
254 if (((e2 >> DESC_TYPE_SHIFT) & 0xf) < 12) {
255 if (dpl < cpl || dpl < rpl)
256 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
257 }
258 }
259 if (!(e2 & DESC_P_MASK))
260 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
261 cpu_x86_load_seg_cache(env, seg_reg, selector,
262 get_seg_base(e1, e2),
263 get_seg_limit(e1, e2),
264 e2);
265 } else {
266 if (seg_reg == R_SS || seg_reg == R_CS)
267 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
268 }
269 }
270
271 #define SWITCH_TSS_JMP 0
272 #define SWITCH_TSS_IRET 1
273 #define SWITCH_TSS_CALL 2
274
275 /* XXX: restore CPU state in registers (PowerPC case) */
276 static void switch_tss(int tss_selector,
277 uint32_t e1, uint32_t e2, int source,
278 uint32_t next_eip)
279 {
280 int tss_limit, tss_limit_max, type, old_tss_limit_max, old_type, v1, v2, i;
281 target_ulong tss_base;
282 uint32_t new_regs[8], new_segs[6];
283 uint32_t new_eflags, new_eip, new_cr3, new_ldt, new_trap;
284 uint32_t old_eflags, eflags_mask;
285 SegmentCache *dt;
286 int index;
287 target_ulong ptr;
288
289 type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
290 LOG_PCALL("switch_tss: sel=0x%04x type=%d src=%d\n", tss_selector, type, source);
291
292 /* if task gate, we read the TSS segment and we load it */
293 if (type == 5) {
294 if (!(e2 & DESC_P_MASK))
295 raise_exception_err(EXCP0B_NOSEG, tss_selector & 0xfffc);
296 tss_selector = e1 >> 16;
297 if (tss_selector & 4)
298 raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
299 if (load_segment(&e1, &e2, tss_selector) != 0)
300 raise_exception_err(EXCP0D_GPF, tss_selector & 0xfffc);
301 if (e2 & DESC_S_MASK)
302 raise_exception_err(EXCP0D_GPF, tss_selector & 0xfffc);
303 type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
304 if ((type & 7) != 1)
305 raise_exception_err(EXCP0D_GPF, tss_selector & 0xfffc);
306 }
307
308 if (!(e2 & DESC_P_MASK))
309 raise_exception_err(EXCP0B_NOSEG, tss_selector & 0xfffc);
310
311 if (type & 8)
312 tss_limit_max = 103;
313 else
314 tss_limit_max = 43;
315 tss_limit = get_seg_limit(e1, e2);
316 tss_base = get_seg_base(e1, e2);
317 if ((tss_selector & 4) != 0 ||
318 tss_limit < tss_limit_max)
319 raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
320 old_type = (env->tr.flags >> DESC_TYPE_SHIFT) & 0xf;
321 if (old_type & 8)
322 old_tss_limit_max = 103;
323 else
324 old_tss_limit_max = 43;
325
326 /* read all the registers from the new TSS */
327 if (type & 8) {
328 /* 32 bit */
329 new_cr3 = ldl_kernel(tss_base + 0x1c);
330 new_eip = ldl_kernel(tss_base + 0x20);
331 new_eflags = ldl_kernel(tss_base + 0x24);
332 for(i = 0; i < 8; i++)
333 new_regs[i] = ldl_kernel(tss_base + (0x28 + i * 4));
334 for(i = 0; i < 6; i++)
335 new_segs[i] = lduw_kernel(tss_base + (0x48 + i * 4));
336 new_ldt = lduw_kernel(tss_base + 0x60);
337 new_trap = ldl_kernel(tss_base + 0x64);
338 } else {
339 /* 16 bit */
340 new_cr3 = 0;
341 new_eip = lduw_kernel(tss_base + 0x0e);
342 new_eflags = lduw_kernel(tss_base + 0x10);
343 for(i = 0; i < 8; i++)
344 new_regs[i] = lduw_kernel(tss_base + (0x12 + i * 2)) | 0xffff0000;
345 for(i = 0; i < 4; i++)
346 new_segs[i] = lduw_kernel(tss_base + (0x22 + i * 4));
347 new_ldt = lduw_kernel(tss_base + 0x2a);
348 new_segs[R_FS] = 0;
349 new_segs[R_GS] = 0;
350 new_trap = 0;
351 }
352
353 /* NOTE: we must avoid memory exceptions during the task switch,
354 so we make dummy accesses before */
355 /* XXX: it can still fail in some cases, so a bigger hack is
356 necessary to valid the TLB after having done the accesses */
357
358 v1 = ldub_kernel(env->tr.base);
359 v2 = ldub_kernel(env->tr.base + old_tss_limit_max);
360 stb_kernel(env->tr.base, v1);
361 stb_kernel(env->tr.base + old_tss_limit_max, v2);
362
363 /* clear busy bit (it is restartable) */
364 if (source == SWITCH_TSS_JMP || source == SWITCH_TSS_IRET) {
365 target_ulong ptr;
366 uint32_t e2;
367 ptr = env->gdt.base + (env->tr.selector & ~7);
368 e2 = ldl_kernel(ptr + 4);
369 e2 &= ~DESC_TSS_BUSY_MASK;
370 stl_kernel(ptr + 4, e2);
371 }
372 old_eflags = compute_eflags();
373 if (source == SWITCH_TSS_IRET)
374 old_eflags &= ~NT_MASK;
375
376 /* save the current state in the old TSS */
377 if (type & 8) {
378 /* 32 bit */
379 stl_kernel(env->tr.base + 0x20, next_eip);
380 stl_kernel(env->tr.base + 0x24, old_eflags);
381 stl_kernel(env->tr.base + (0x28 + 0 * 4), EAX);
382 stl_kernel(env->tr.base + (0x28 + 1 * 4), ECX);
383 stl_kernel(env->tr.base + (0x28 + 2 * 4), EDX);
384 stl_kernel(env->tr.base + (0x28 + 3 * 4), EBX);
385 stl_kernel(env->tr.base + (0x28 + 4 * 4), ESP);
386 stl_kernel(env->tr.base + (0x28 + 5 * 4), EBP);
387 stl_kernel(env->tr.base + (0x28 + 6 * 4), ESI);
388 stl_kernel(env->tr.base + (0x28 + 7 * 4), EDI);
389 for(i = 0; i < 6; i++)
390 stw_kernel(env->tr.base + (0x48 + i * 4), env->segs[i].selector);
391 } else {
392 /* 16 bit */
393 stw_kernel(env->tr.base + 0x0e, next_eip);
394 stw_kernel(env->tr.base + 0x10, old_eflags);
395 stw_kernel(env->tr.base + (0x12 + 0 * 2), EAX);
396 stw_kernel(env->tr.base + (0x12 + 1 * 2), ECX);
397 stw_kernel(env->tr.base + (0x12 + 2 * 2), EDX);
398 stw_kernel(env->tr.base + (0x12 + 3 * 2), EBX);
399 stw_kernel(env->tr.base + (0x12 + 4 * 2), ESP);
400 stw_kernel(env->tr.base + (0x12 + 5 * 2), EBP);
401 stw_kernel(env->tr.base + (0x12 + 6 * 2), ESI);
402 stw_kernel(env->tr.base + (0x12 + 7 * 2), EDI);
403 for(i = 0; i < 4; i++)
404 stw_kernel(env->tr.base + (0x22 + i * 4), env->segs[i].selector);
405 }
406
407 /* now if an exception occurs, it will occurs in the next task
408 context */
409
410 if (source == SWITCH_TSS_CALL) {
411 stw_kernel(tss_base, env->tr.selector);
412 new_eflags |= NT_MASK;
413 }
414
415 /* set busy bit */
416 if (source == SWITCH_TSS_JMP || source == SWITCH_TSS_CALL) {
417 target_ulong ptr;
418 uint32_t e2;
419 ptr = env->gdt.base + (tss_selector & ~7);
420 e2 = ldl_kernel(ptr + 4);
421 e2 |= DESC_TSS_BUSY_MASK;
422 stl_kernel(ptr + 4, e2);
423 }
424
425 /* set the new CPU state */
426 /* from this point, any exception which occurs can give problems */
427 env->cr[0] |= CR0_TS_MASK;
428 env->hflags |= HF_TS_MASK;
429 env->tr.selector = tss_selector;
430 env->tr.base = tss_base;
431 env->tr.limit = tss_limit;
432 env->tr.flags = e2 & ~DESC_TSS_BUSY_MASK;
433
434 if ((type & 8) && (env->cr[0] & CR0_PG_MASK)) {
435 cpu_x86_update_cr3(env, new_cr3);
436 }
437
438 /* load all registers without an exception, then reload them with
439 possible exception */
440 env->eip = new_eip;
441 eflags_mask = TF_MASK | AC_MASK | ID_MASK |
442 IF_MASK | IOPL_MASK | VM_MASK | RF_MASK | NT_MASK;
443 if (!(type & 8))
444 eflags_mask &= 0xffff;
445 load_eflags(new_eflags, eflags_mask);
446 /* XXX: what to do in 16 bit case ? */
447 EAX = new_regs[0];
448 ECX = new_regs[1];
449 EDX = new_regs[2];
450 EBX = new_regs[3];
451 ESP = new_regs[4];
452 EBP = new_regs[5];
453 ESI = new_regs[6];
454 EDI = new_regs[7];
455 if (new_eflags & VM_MASK) {
456 for(i = 0; i < 6; i++)
457 load_seg_vm(i, new_segs[i]);
458 /* in vm86, CPL is always 3 */
459 cpu_x86_set_cpl(env, 3);
460 } else {
461 /* CPL is set the RPL of CS */
462 cpu_x86_set_cpl(env, new_segs[R_CS] & 3);
463 /* first just selectors as the rest may trigger exceptions */
464 for(i = 0; i < 6; i++)
465 cpu_x86_load_seg_cache(env, i, new_segs[i], 0, 0, 0);
466 }
467
468 env->ldt.selector = new_ldt & ~4;
469 env->ldt.base = 0;
470 env->ldt.limit = 0;
471 env->ldt.flags = 0;
472
473 /* load the LDT */
474 if (new_ldt & 4)
475 raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
476
477 if ((new_ldt & 0xfffc) != 0) {
478 dt = &env->gdt;
479 index = new_ldt & ~7;
480 if ((index + 7) > dt->limit)
481 raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
482 ptr = dt->base + index;
483 e1 = ldl_kernel(ptr);
484 e2 = ldl_kernel(ptr + 4);
485 if ((e2 & DESC_S_MASK) || ((e2 >> DESC_TYPE_SHIFT) & 0xf) != 2)
486 raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
487 if (!(e2 & DESC_P_MASK))
488 raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
489 load_seg_cache_raw_dt(&env->ldt, e1, e2);
490 }
491
492 /* load the segments */
493 if (!(new_eflags & VM_MASK)) {
494 tss_load_seg(R_CS, new_segs[R_CS]);
495 tss_load_seg(R_SS, new_segs[R_SS]);
496 tss_load_seg(R_ES, new_segs[R_ES]);
497 tss_load_seg(R_DS, new_segs[R_DS]);
498 tss_load_seg(R_FS, new_segs[R_FS]);
499 tss_load_seg(R_GS, new_segs[R_GS]);
500 }
501
502 /* check that EIP is in the CS segment limits */
503 if (new_eip > env->segs[R_CS].limit) {
504 /* XXX: different exception if CALL ? */
505 raise_exception_err(EXCP0D_GPF, 0);
506 }
507
508 #ifndef CONFIG_USER_ONLY
509 /* reset local breakpoints */
510 if (env->dr[7] & 0x55) {
511 for (i = 0; i < 4; i++) {
512 if (hw_breakpoint_enabled(env->dr[7], i) == 0x1)
513 hw_breakpoint_remove(env, i);
514 }
515 env->dr[7] &= ~0x55;
516 }
517 #endif
518 }
519
520 /* check if Port I/O is allowed in TSS */
521 static inline void check_io(int addr, int size)
522 {
523 int io_offset, val, mask;
524
525 /* TSS must be a valid 32 bit one */
526 if (!(env->tr.flags & DESC_P_MASK) ||
527 ((env->tr.flags >> DESC_TYPE_SHIFT) & 0xf) != 9 ||
528 env->tr.limit < 103)
529 goto fail;
530 io_offset = lduw_kernel(env->tr.base + 0x66);
531 io_offset += (addr >> 3);
532 /* Note: the check needs two bytes */
533 if ((io_offset + 1) > env->tr.limit)
534 goto fail;
535 val = lduw_kernel(env->tr.base + io_offset);
536 val >>= (addr & 7);
537 mask = (1 << size) - 1;
538 /* all bits must be zero to allow the I/O */
539 if ((val & mask) != 0) {
540 fail:
541 raise_exception_err(EXCP0D_GPF, 0);
542 }
543 }
544
545 void helper_check_iob(uint32_t t0)
546 {
547 check_io(t0, 1);
548 }
549
550 void helper_check_iow(uint32_t t0)
551 {
552 check_io(t0, 2);
553 }
554
555 void helper_check_iol(uint32_t t0)
556 {
557 check_io(t0, 4);
558 }
559
560 void helper_outb(uint32_t port, uint32_t data)
561 {
562 cpu_outb(env, port, data & 0xff);
563 }
564
565 target_ulong helper_inb(uint32_t port)
566 {
567 return cpu_inb(env, port);
568 }
569
570 void helper_outw(uint32_t port, uint32_t data)
571 {
572 cpu_outw(env, port, data & 0xffff);
573 }
574
575 target_ulong helper_inw(uint32_t port)
576 {
577 return cpu_inw(env, port);
578 }
579
580 void helper_outl(uint32_t port, uint32_t data)
581 {
582 cpu_outl(env, port, data);
583 }
584
585 target_ulong helper_inl(uint32_t port)
586 {
587 return cpu_inl(env, port);
588 }
589
590 static inline unsigned int get_sp_mask(unsigned int e2)
591 {
592 if (e2 & DESC_B_MASK)
593 return 0xffffffff;
594 else
595 return 0xffff;
596 }
597
598 #ifdef TARGET_X86_64
599 #define SET_ESP(val, sp_mask)\
600 do {\
601 if ((sp_mask) == 0xffff)\
602 ESP = (ESP & ~0xffff) | ((val) & 0xffff);\
603 else if ((sp_mask) == 0xffffffffLL)\
604 ESP = (uint32_t)(val);\
605 else\
606 ESP = (val);\
607 } while (0)
608 #else
609 #define SET_ESP(val, sp_mask) ESP = (ESP & ~(sp_mask)) | ((val) & (sp_mask))
610 #endif
611
612 /* in 64-bit machines, this can overflow. So this segment addition macro
613 * can be used to trim the value to 32-bit whenever needed */
614 #define SEG_ADDL(ssp, sp, sp_mask) ((uint32_t)((ssp) + (sp & (sp_mask))))
615
616 /* XXX: add a is_user flag to have proper security support */
617 #define PUSHW(ssp, sp, sp_mask, val)\
618 {\
619 sp -= 2;\
620 stw_kernel((ssp) + (sp & (sp_mask)), (val));\
621 }
622
623 #define PUSHL(ssp, sp, sp_mask, val)\
624 {\
625 sp -= 4;\
626 stl_kernel(SEG_ADDL(ssp, sp, sp_mask), (uint32_t)(val));\
627 }
628
629 #define POPW(ssp, sp, sp_mask, val)\
630 {\
631 val = lduw_kernel((ssp) + (sp & (sp_mask)));\
632 sp += 2;\
633 }
634
635 #define POPL(ssp, sp, sp_mask, val)\
636 {\
637 val = (uint32_t)ldl_kernel(SEG_ADDL(ssp, sp, sp_mask));\
638 sp += 4;\
639 }
640
641 /* protected mode interrupt */
642 static void do_interrupt_protected(int intno, int is_int, int error_code,
643 unsigned int next_eip, int is_hw)
644 {
645 SegmentCache *dt;
646 target_ulong ptr, ssp;
647 int type, dpl, selector, ss_dpl, cpl;
648 int has_error_code, new_stack, shift;
649 uint32_t e1, e2, offset, ss = 0, esp, ss_e1 = 0, ss_e2 = 0;
650 uint32_t old_eip, sp_mask;
651
652 has_error_code = 0;
653 if (!is_int && !is_hw) {
654 switch(intno) {
655 case 8:
656 case 10:
657 case 11:
658 case 12:
659 case 13:
660 case 14:
661 case 17:
662 has_error_code = 1;
663 break;
664 }
665 }
666 if (is_int)
667 old_eip = next_eip;
668 else
669 old_eip = env->eip;
670
671 dt = &env->idt;
672 if (intno * 8 + 7 > dt->limit)
673 raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
674 ptr = dt->base + intno * 8;
675 e1 = ldl_kernel(ptr);
676 e2 = ldl_kernel(ptr + 4);
677 /* check gate type */
678 type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;
679 switch(type) {
680 case 5: /* task gate */
681 /* must do that check here to return the correct error code */
682 if (!(e2 & DESC_P_MASK))
683 raise_exception_err(EXCP0B_NOSEG, intno * 8 + 2);
684 switch_tss(intno * 8, e1, e2, SWITCH_TSS_CALL, old_eip);
685 if (has_error_code) {
686 int type;
687 uint32_t mask;
688 /* push the error code */
689 type = (env->tr.flags >> DESC_TYPE_SHIFT) & 0xf;
690 shift = type >> 3;
691 if (env->segs[R_SS].flags & DESC_B_MASK)
692 mask = 0xffffffff;
693 else
694 mask = 0xffff;
695 esp = (ESP - (2 << shift)) & mask;
696 ssp = env->segs[R_SS].base + esp;
697 if (shift)
698 stl_kernel(ssp, error_code);
699 else
700 stw_kernel(ssp, error_code);
701 SET_ESP(esp, mask);
702 }
703 return;
704 case 6: /* 286 interrupt gate */
705 case 7: /* 286 trap gate */
706 case 14: /* 386 interrupt gate */
707 case 15: /* 386 trap gate */
708 break;
709 default:
710 raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
711 break;
712 }
713 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
714 cpl = env->hflags & HF_CPL_MASK;
715 /* check privilege if software int */
716 if (is_int && dpl < cpl)
717 raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
718 /* check valid bit */
719 if (!(e2 & DESC_P_MASK))
720 raise_exception_err(EXCP0B_NOSEG, intno * 8 + 2);
721 selector = e1 >> 16;
722 offset = (e2 & 0xffff0000) | (e1 & 0x0000ffff);
723 if ((selector & 0xfffc) == 0)
724 raise_exception_err(EXCP0D_GPF, 0);
725
726 if (load_segment(&e1, &e2, selector) != 0)
727 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
728 if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))
729 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
730 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
731 if (dpl > cpl)
732 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
733 if (!(e2 & DESC_P_MASK))
734 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
735 if (!(e2 & DESC_C_MASK) && dpl < cpl) {
736 /* to inner privilege */
737 get_ss_esp_from_tss(&ss, &esp, dpl);
738 if ((ss & 0xfffc) == 0)
739 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
740 if ((ss & 3) != dpl)
741 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
742 if (load_segment(&ss_e1, &ss_e2, ss) != 0)
743 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
744 ss_dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
745 if (ss_dpl != dpl)
746 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
747 if (!(ss_e2 & DESC_S_MASK) ||
748 (ss_e2 & DESC_CS_MASK) ||
749 !(ss_e2 & DESC_W_MASK))
750 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
751 if (!(ss_e2 & DESC_P_MASK))
752 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
753 new_stack = 1;
754 sp_mask = get_sp_mask(ss_e2);
755 ssp = get_seg_base(ss_e1, ss_e2);
756 } else if ((e2 & DESC_C_MASK) || dpl == cpl) {
757 /* to same privilege */
758 if (env->eflags & VM_MASK)
759 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
760 new_stack = 0;
761 sp_mask = get_sp_mask(env->segs[R_SS].flags);
762 ssp = env->segs[R_SS].base;
763 esp = ESP;
764 dpl = cpl;
765 } else {
766 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
767 new_stack = 0; /* avoid warning */
768 sp_mask = 0; /* avoid warning */
769 ssp = 0; /* avoid warning */
770 esp = 0; /* avoid warning */
771 }
772
773 shift = type >> 3;
774
775 #if 0
776 /* XXX: check that enough room is available */
777 push_size = 6 + (new_stack << 2) + (has_error_code << 1);
778 if (env->eflags & VM_MASK)
779 push_size += 8;
780 push_size <<= shift;
781 #endif
782 if (shift == 1) {
783 if (new_stack) {
784 if (env->eflags & VM_MASK) {
785 PUSHL(ssp, esp, sp_mask, env->segs[R_GS].selector);
786 PUSHL(ssp, esp, sp_mask, env->segs[R_FS].selector);
787 PUSHL(ssp, esp, sp_mask, env->segs[R_DS].selector);
788 PUSHL(ssp, esp, sp_mask, env->segs[R_ES].selector);
789 }
790 PUSHL(ssp, esp, sp_mask, env->segs[R_SS].selector);
791 PUSHL(ssp, esp, sp_mask, ESP);
792 }
793 PUSHL(ssp, esp, sp_mask, compute_eflags());
794 PUSHL(ssp, esp, sp_mask, env->segs[R_CS].selector);
795 PUSHL(ssp, esp, sp_mask, old_eip);
796 if (has_error_code) {
797 PUSHL(ssp, esp, sp_mask, error_code);
798 }
799 } else {
800 if (new_stack) {
801 if (env->eflags & VM_MASK) {
802 PUSHW(ssp, esp, sp_mask, env->segs[R_GS].selector);
803 PUSHW(ssp, esp, sp_mask, env->segs[R_FS].selector);
804 PUSHW(ssp, esp, sp_mask, env->segs[R_DS].selector);
805 PUSHW(ssp, esp, sp_mask, env->segs[R_ES].selector);
806 }
807 PUSHW(ssp, esp, sp_mask, env->segs[R_SS].selector);
808 PUSHW(ssp, esp, sp_mask, ESP);
809 }
810 PUSHW(ssp, esp, sp_mask, compute_eflags());
811 PUSHW(ssp, esp, sp_mask, env->segs[R_CS].selector);
812 PUSHW(ssp, esp, sp_mask, old_eip);
813 if (has_error_code) {
814 PUSHW(ssp, esp, sp_mask, error_code);
815 }
816 }
817
818 if (new_stack) {
819 if (env->eflags & VM_MASK) {
820 cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0, 0);
821 cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0, 0);
822 cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0, 0);
823 cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0, 0);
824 }
825 ss = (ss & ~3) | dpl;
826 cpu_x86_load_seg_cache(env, R_SS, ss,
827 ssp, get_seg_limit(ss_e1, ss_e2), ss_e2);
828 }
829 SET_ESP(esp, sp_mask);
830
831 selector = (selector & ~3) | dpl;
832 cpu_x86_load_seg_cache(env, R_CS, selector,
833 get_seg_base(e1, e2),
834 get_seg_limit(e1, e2),
835 e2);
836 cpu_x86_set_cpl(env, dpl);
837 env->eip = offset;
838
839 /* interrupt gate clear IF mask */
840 if ((type & 1) == 0) {
841 env->eflags &= ~IF_MASK;
842 }
843 env->eflags &= ~(TF_MASK | VM_MASK | RF_MASK | NT_MASK);
844 }
845
846 #ifdef TARGET_X86_64
847
848 #define PUSHQ(sp, val)\
849 {\
850 sp -= 8;\
851 stq_kernel(sp, (val));\
852 }
853
854 #define POPQ(sp, val)\
855 {\
856 val = ldq_kernel(sp);\
857 sp += 8;\
858 }
859
860 static inline target_ulong get_rsp_from_tss(int level)
861 {
862 int index;
863
864 #if 0
865 printf("TR: base=" TARGET_FMT_lx " limit=%x\n",
866 env->tr.base, env->tr.limit);
867 #endif
868
869 if (!(env->tr.flags & DESC_P_MASK))
870 cpu_abort(env, "invalid tss");
871 index = 8 * level + 4;
872 if ((index + 7) > env->tr.limit)
873 raise_exception_err(EXCP0A_TSS, env->tr.selector & 0xfffc);
874 return ldq_kernel(env->tr.base + index);
875 }
876
877 /* 64 bit interrupt */
878 static void do_interrupt64(int intno, int is_int, int error_code,
879 target_ulong next_eip, int is_hw)
880 {
881 SegmentCache *dt;
882 target_ulong ptr;
883 int type, dpl, selector, cpl, ist;
884 int has_error_code, new_stack;
885 uint32_t e1, e2, e3, ss;
886 target_ulong old_eip, esp, offset;
887
888 has_error_code = 0;
889 if (!is_int && !is_hw) {
890 switch(intno) {
891 case 8:
892 case 10:
893 case 11:
894 case 12:
895 case 13:
896 case 14:
897 case 17:
898 has_error_code = 1;
899 break;
900 }
901 }
902 if (is_int)
903 old_eip = next_eip;
904 else
905 old_eip = env->eip;
906
907 dt = &env->idt;
908 if (intno * 16 + 15 > dt->limit)
909 raise_exception_err(EXCP0D_GPF, intno * 16 + 2);
910 ptr = dt->base + intno * 16;
911 e1 = ldl_kernel(ptr);
912 e2 = ldl_kernel(ptr + 4);
913 e3 = ldl_kernel(ptr + 8);
914 /* check gate type */
915 type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;
916 switch(type) {
917 case 14: /* 386 interrupt gate */
918 case 15: /* 386 trap gate */
919 break;
920 default:
921 raise_exception_err(EXCP0D_GPF, intno * 16 + 2);
922 break;
923 }
924 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
925 cpl = env->hflags & HF_CPL_MASK;
926 /* check privilege if software int */
927 if (is_int && dpl < cpl)
928 raise_exception_err(EXCP0D_GPF, intno * 16 + 2);
929 /* check valid bit */
930 if (!(e2 & DESC_P_MASK))
931 raise_exception_err(EXCP0B_NOSEG, intno * 16 + 2);
932 selector = e1 >> 16;
933 offset = ((target_ulong)e3 << 32) | (e2 & 0xffff0000) | (e1 & 0x0000ffff);
934 ist = e2 & 7;
935 if ((selector & 0xfffc) == 0)
936 raise_exception_err(EXCP0D_GPF, 0);
937
938 if (load_segment(&e1, &e2, selector) != 0)
939 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
940 if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))
941 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
942 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
943 if (dpl > cpl)
944 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
945 if (!(e2 & DESC_P_MASK))
946 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
947 if (!(e2 & DESC_L_MASK) || (e2 & DESC_B_MASK))
948 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
949 if ((!(e2 & DESC_C_MASK) && dpl < cpl) || ist != 0) {
950 /* to inner privilege */
951 if (ist != 0)
952 esp = get_rsp_from_tss(ist + 3);
953 else
954 esp = get_rsp_from_tss(dpl);
955 esp &= ~0xfLL; /* align stack */
956 ss = 0;
957 new_stack = 1;
958 } else if ((e2 & DESC_C_MASK) || dpl == cpl) {
959 /* to same privilege */
960 if (env->eflags & VM_MASK)
961 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
962 new_stack = 0;
963 if (ist != 0)
964 esp = get_rsp_from_tss(ist + 3);
965 else
966 esp = ESP;
967 esp &= ~0xfLL; /* align stack */
968 dpl = cpl;
969 } else {
970 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
971 new_stack = 0; /* avoid warning */
972 esp = 0; /* avoid warning */
973 }
974
975 PUSHQ(esp, env->segs[R_SS].selector);
976 PUSHQ(esp, ESP);
977 PUSHQ(esp, compute_eflags());
978 PUSHQ(esp, env->segs[R_CS].selector);
979 PUSHQ(esp, old_eip);
980 if (has_error_code) {
981 PUSHQ(esp, error_code);
982 }
983
984 if (new_stack) {
985 ss = 0 | dpl;
986 cpu_x86_load_seg_cache(env, R_SS, ss, 0, 0, 0);
987 }
988 ESP = esp;
989
990 selector = (selector & ~3) | dpl;
991 cpu_x86_load_seg_cache(env, R_CS, selector,
992 get_seg_base(e1, e2),
993 get_seg_limit(e1, e2),
994 e2);
995 cpu_x86_set_cpl(env, dpl);
996 env->eip = offset;
997
998 /* interrupt gate clear IF mask */
999 if ((type & 1) == 0) {
1000 env->eflags &= ~IF_MASK;
1001 }
1002 env->eflags &= ~(TF_MASK | VM_MASK | RF_MASK | NT_MASK);
1003 }
1004 #endif
1005
1006 #ifdef TARGET_X86_64
1007 #if defined(CONFIG_USER_ONLY)
1008 void helper_syscall(int next_eip_addend)
1009 {
1010 env->exception_index = EXCP_SYSCALL;
1011 env->exception_next_eip = env->eip + next_eip_addend;
1012 cpu_loop_exit();
1013 }
1014 #else
1015 void helper_syscall(int next_eip_addend)
1016 {
1017 int selector;
1018
1019 if (!(env->efer & MSR_EFER_SCE)) {
1020 raise_exception_err(EXCP06_ILLOP, 0);
1021 }
1022 selector = (env->star >> 32) & 0xffff;
1023 if (env->hflags & HF_LMA_MASK) {
1024 int code64;
1025
1026 ECX = env->eip + next_eip_addend;
1027 env->regs[11] = compute_eflags();
1028
1029 code64 = env->hflags & HF_CS64_MASK;
1030
1031 cpu_x86_set_cpl(env, 0);
1032 cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
1033 0, 0xffffffff,
1034 DESC_G_MASK | DESC_P_MASK |
1035 DESC_S_MASK |
1036 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
1037 cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
1038 0, 0xffffffff,
1039 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1040 DESC_S_MASK |
1041 DESC_W_MASK | DESC_A_MASK);
1042 env->eflags &= ~env->fmask;
1043 load_eflags(env->eflags, 0);
1044 if (code64)
1045 env->eip = env->lstar;
1046 else
1047 env->eip = env->cstar;
1048 } else {
1049 ECX = (uint32_t)(env->eip + next_eip_addend);
1050
1051 cpu_x86_set_cpl(env, 0);
1052 cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
1053 0, 0xffffffff,
1054 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1055 DESC_S_MASK |
1056 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
1057 cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
1058 0, 0xffffffff,
1059 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1060 DESC_S_MASK |
1061 DESC_W_MASK | DESC_A_MASK);
1062 env->eflags &= ~(IF_MASK | RF_MASK | VM_MASK);
1063 env->eip = (uint32_t)env->star;
1064 }
1065 }
1066 #endif
1067 #endif
1068
1069 #ifdef TARGET_X86_64
1070 void helper_sysret(int dflag)
1071 {
1072 int cpl, selector;
1073
1074 if (!(env->efer & MSR_EFER_SCE)) {
1075 raise_exception_err(EXCP06_ILLOP, 0);
1076 }
1077 cpl = env->hflags & HF_CPL_MASK;
1078 if (!(env->cr[0] & CR0_PE_MASK) || cpl != 0) {
1079 raise_exception_err(EXCP0D_GPF, 0);
1080 }
1081 selector = (env->star >> 48) & 0xffff;
1082 if (env->hflags & HF_LMA_MASK) {
1083 if (dflag == 2) {
1084 cpu_x86_load_seg_cache(env, R_CS, (selector + 16) | 3,
1085 0, 0xffffffff,
1086 DESC_G_MASK | DESC_P_MASK |
1087 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1088 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK |
1089 DESC_L_MASK);
1090 env->eip = ECX;
1091 } else {
1092 cpu_x86_load_seg_cache(env, R_CS, selector | 3,
1093 0, 0xffffffff,
1094 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1095 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1096 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
1097 env->eip = (uint32_t)ECX;
1098 }
1099 cpu_x86_load_seg_cache(env, R_SS, selector + 8,
1100 0, 0xffffffff,
1101 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1102 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1103 DESC_W_MASK | DESC_A_MASK);
1104 load_eflags((uint32_t)(env->regs[11]), TF_MASK | AC_MASK | ID_MASK |
1105 IF_MASK | IOPL_MASK | VM_MASK | RF_MASK | NT_MASK);
1106 cpu_x86_set_cpl(env, 3);
1107 } else {
1108 cpu_x86_load_seg_cache(env, R_CS, selector | 3,
1109 0, 0xffffffff,
1110 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1111 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1112 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
1113 env->eip = (uint32_t)ECX;
1114 cpu_x86_load_seg_cache(env, R_SS, selector + 8,
1115 0, 0xffffffff,
1116 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1117 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1118 DESC_W_MASK | DESC_A_MASK);
1119 env->eflags |= IF_MASK;
1120 cpu_x86_set_cpl(env, 3);
1121 }
1122 #ifdef USE_KQEMU
1123 if (kqemu_is_ok(env)) {
1124 if (env->hflags & HF_LMA_MASK)
1125 CC_OP = CC_OP_EFLAGS;
1126 env->exception_index = -1;
1127 cpu_loop_exit();
1128 }
1129 #endif
1130 }
1131 #endif
1132
1133 /* real mode interrupt */
1134 static void do_interrupt_real(int intno, int is_int, int error_code,
1135 unsigned int next_eip)
1136 {
1137 SegmentCache *dt;
1138 target_ulong ptr, ssp;
1139 int selector;
1140 uint32_t offset, esp;
1141 uint32_t old_cs, old_eip;
1142
1143 /* real mode (simpler !) */
1144 dt = &env->idt;
1145 if (intno * 4 + 3 > dt->limit)
1146 raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
1147 ptr = dt->base + intno * 4;
1148 offset = lduw_kernel(ptr);
1149 selector = lduw_kernel(ptr + 2);
1150 esp = ESP;
1151 ssp = env->segs[R_SS].base;
1152 if (is_int)
1153 old_eip = next_eip;
1154 else
1155 old_eip = env->eip;
1156 old_cs = env->segs[R_CS].selector;
1157 /* XXX: use SS segment size ? */
1158 PUSHW(ssp, esp, 0xffff, compute_eflags());
1159 PUSHW(ssp, esp, 0xffff, old_cs);
1160 PUSHW(ssp, esp, 0xffff, old_eip);
1161
1162 /* update processor state */
1163 ESP = (ESP & ~0xffff) | (esp & 0xffff);
1164 env->eip = offset;
1165 env->segs[R_CS].selector = selector;
1166 env->segs[R_CS].base = (selector << 4);
1167 env->eflags &= ~(IF_MASK | TF_MASK | AC_MASK | RF_MASK);
1168 }
1169
1170 /* fake user mode interrupt */
1171 void do_interrupt_user(int intno, int is_int, int error_code,
1172 target_ulong next_eip)
1173 {
1174 SegmentCache *dt;
1175 target_ulong ptr;
1176 int dpl, cpl, shift;
1177 uint32_t e2;
1178
1179 dt = &env->idt;
1180 if (env->hflags & HF_LMA_MASK) {
1181 shift = 4;
1182 } else {
1183 shift = 3;
1184 }
1185 ptr = dt->base + (intno << shift);
1186 e2 = ldl_kernel(ptr + 4);
1187
1188 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
1189 cpl = env->hflags & HF_CPL_MASK;
1190 /* check privilege if software int */
1191 if (is_int && dpl < cpl)
1192 raise_exception_err(EXCP0D_GPF, (intno << shift) + 2);
1193
1194 /* Since we emulate only user space, we cannot do more than
1195 exiting the emulation with the suitable exception and error
1196 code */
1197 if (is_int)
1198 EIP = next_eip;
1199 }
1200
1201 /*
1202 * Begin execution of an interruption. is_int is TRUE if coming from
1203 * the int instruction. next_eip is the EIP value AFTER the interrupt
1204 * instruction. It is only relevant if is_int is TRUE.
1205 */
1206 void do_interrupt(int intno, int is_int, int error_code,
1207 target_ulong next_eip, int is_hw)
1208 {
1209 if (qemu_loglevel_mask(CPU_LOG_INT)) {
1210 if ((env->cr[0] & CR0_PE_MASK)) {
1211 static int count;
1212 qemu_log("%6d: v=%02x e=%04x i=%d cpl=%d IP=%04x:" TARGET_FMT_lx " pc=" TARGET_FMT_lx " SP=%04x:" TARGET_FMT_lx,
1213 count, intno, error_code, is_int,
1214 env->hflags & HF_CPL_MASK,
1215 env->segs[R_CS].selector, EIP,
1216 (int)env->segs[R_CS].base + EIP,
1217 env->segs[R_SS].selector, ESP);
1218 if (intno == 0x0e) {
1219 qemu_log(" CR2=" TARGET_FMT_lx, env->cr[2]);
1220 } else {
1221 qemu_log(" EAX=" TARGET_FMT_lx, EAX);
1222 }
1223 qemu_log("\n");
1224 log_cpu_state(env, X86_DUMP_CCOP);
1225 #if 0
1226 {
1227 int i;
1228 uint8_t *ptr;
1229 qemu_log(" code=");
1230 ptr = env->segs[R_CS].base + env->eip;
1231 for(i = 0; i < 16; i++) {
1232 qemu_log(" %02x", ldub(ptr + i));
1233 }
1234 qemu_log("\n");
1235 }
1236 #endif
1237 count++;
1238 }
1239 }
1240 if (env->cr[0] & CR0_PE_MASK) {
1241 #ifdef TARGET_X86_64
1242 if (env->hflags & HF_LMA_MASK) {
1243 do_interrupt64(intno, is_int, error_code, next_eip, is_hw);
1244 } else
1245 #endif
1246 {
1247 do_interrupt_protected(intno, is_int, error_code, next_eip, is_hw);
1248 }
1249 } else {
1250 do_interrupt_real(intno, is_int, error_code, next_eip);
1251 }
1252 }
1253
1254 /* This should come from sysemu.h - if we could include it here... */
1255 void qemu_system_reset_request(void);
1256
1257 /*
1258 * Check nested exceptions and change to double or triple fault if
1259 * needed. It should only be called, if this is not an interrupt.
1260 * Returns the new exception number.
1261 */
1262 static int check_exception(int intno, int *error_code)
1263 {
1264 int first_contributory = env->old_exception == 0 ||
1265 (env->old_exception >= 10 &&
1266 env->old_exception <= 13);
1267 int second_contributory = intno == 0 ||
1268 (intno >= 10 && intno <= 13);
1269
1270 qemu_log_mask(CPU_LOG_INT, "check_exception old: 0x%x new 0x%x\n",
1271 env->old_exception, intno);
1272
1273 #if !defined(CONFIG_USER_ONLY)
1274 if (env->old_exception == EXCP08_DBLE) {
1275 if (env->hflags & HF_SVMI_MASK)
1276 helper_vmexit(SVM_EXIT_SHUTDOWN, 0); /* does not return */
1277
1278 if (qemu_loglevel_mask(CPU_LOG_RESET))
1279 fprintf(logfile, "Triple fault\n");
1280
1281 qemu_system_reset_request();
1282 return EXCP_HLT;
1283 }
1284 #endif
1285
1286 if ((first_contributory && second_contributory)
1287 || (env->old_exception == EXCP0E_PAGE &&
1288 (second_contributory || (intno == EXCP0E_PAGE)))) {
1289 intno = EXCP08_DBLE;
1290 *error_code = 0;
1291 }
1292
1293 if (second_contributory || (intno == EXCP0E_PAGE) ||
1294 (intno == EXCP08_DBLE))
1295 env->old_exception = intno;
1296
1297 return intno;
1298 }
1299
1300 /*
1301 * Signal an interruption. It is executed in the main CPU loop.
1302 * is_int is TRUE if coming from the int instruction. next_eip is the
1303 * EIP value AFTER the interrupt instruction. It is only relevant if
1304 * is_int is TRUE.
1305 */
1306 static void QEMU_NORETURN raise_interrupt(int intno, int is_int, int error_code,
1307 int next_eip_addend)
1308 {
1309 if (!is_int) {
1310 helper_svm_check_intercept_param(SVM_EXIT_EXCP_BASE + intno, error_code);
1311 intno = check_exception(intno, &error_code);
1312 } else {
1313 helper_svm_check_intercept_param(SVM_EXIT_SWINT, 0);
1314 }
1315
1316 env->exception_index = intno;
1317 env->error_code = error_code;
1318 env->exception_is_int = is_int;
1319 env->exception_next_eip = env->eip + next_eip_addend;
1320 cpu_loop_exit();
1321 }
1322
1323 /* shortcuts to generate exceptions */
1324
1325 void raise_exception_err(int exception_index, int error_code)
1326 {
1327 raise_interrupt(exception_index, 0, error_code, 0);
1328 }
1329
1330 void raise_exception(int exception_index)
1331 {
1332 raise_interrupt(exception_index, 0, 0, 0);
1333 }
1334
1335 /* SMM support */
1336
1337 #if defined(CONFIG_USER_ONLY)
1338
1339 void do_smm_enter(void)
1340 {
1341 }
1342
1343 void helper_rsm(void)
1344 {
1345 }
1346
1347 #else
1348
1349 #ifdef TARGET_X86_64
1350 #define SMM_REVISION_ID 0x00020064
1351 #else
1352 #define SMM_REVISION_ID 0x00020000
1353 #endif
1354
1355 void do_smm_enter(void)
1356 {
1357 target_ulong sm_state;
1358 SegmentCache *dt;
1359 int i, offset;
1360
1361 qemu_log_mask(CPU_LOG_INT, "SMM: enter\n");
1362 log_cpu_state_mask(CPU_LOG_INT, env, X86_DUMP_CCOP);
1363
1364 env->hflags |= HF_SMM_MASK;
1365 cpu_smm_update(env);
1366
1367 sm_state = env->smbase + 0x8000;
1368
1369 #ifdef TARGET_X86_64
1370 for(i = 0; i < 6; i++) {
1371 dt = &env->segs[i];
1372 offset = 0x7e00 + i * 16;
1373 stw_phys(sm_state + offset, dt->selector);
1374 stw_phys(sm_state + offset + 2, (dt->flags >> 8) & 0xf0ff);
1375 stl_phys(sm_state + offset + 4, dt->limit);
1376 stq_phys(sm_state + offset + 8, dt->base);
1377 }
1378
1379 stq_phys(sm_state + 0x7e68, env->gdt.base);
1380 stl_phys(sm_state + 0x7e64, env->gdt.limit);
1381
1382 stw_phys(sm_state + 0x7e70, env->ldt.selector);
1383 stq_phys(sm_state + 0x7e78, env->ldt.base);
1384 stl_phys(sm_state + 0x7e74, env->ldt.limit);
1385 stw_phys(sm_state + 0x7e72, (env->ldt.flags >> 8) & 0xf0ff);
1386
1387 stq_phys(sm_state + 0x7e88, env->idt.base);
1388 stl_phys(sm_state + 0x7e84, env->idt.limit);
1389
1390 stw_phys(sm_state + 0x7e90, env->tr.selector);
1391 stq_phys(sm_state + 0x7e98, env->tr.base);
1392 stl_phys(sm_state + 0x7e94, env->tr.limit);
1393 stw_phys(sm_state + 0x7e92, (env->tr.flags >> 8) & 0xf0ff);
1394
1395 stq_phys(sm_state + 0x7ed0, env->efer);
1396
1397 stq_phys(sm_state + 0x7ff8, EAX);
1398 stq_phys(sm_state + 0x7ff0, ECX);
1399 stq_phys(sm_state + 0x7fe8, EDX);
1400 stq_phys(sm_state + 0x7fe0, EBX);
1401 stq_phys(sm_state + 0x7fd8, ESP);
1402 stq_phys(sm_state + 0x7fd0, EBP);
1403 stq_phys(sm_state + 0x7fc8, ESI);
1404 stq_phys(sm_state + 0x7fc0, EDI);
1405 for(i = 8; i < 16; i++)
1406 stq_phys(sm_state + 0x7ff8 - i * 8, env->regs[i]);
1407 stq_phys(sm_state + 0x7f78, env->eip);
1408 stl_phys(sm_state + 0x7f70, compute_eflags());
1409 stl_phys(sm_state + 0x7f68, env->dr[6]);
1410 stl_phys(sm_state + 0x7f60, env->dr[7]);
1411
1412 stl_phys(sm_state + 0x7f48, env->cr[4]);
1413 stl_phys(sm_state + 0x7f50, env->cr[3]);
1414 stl_phys(sm_state + 0x7f58, env->cr[0]);
1415
1416 stl_phys(sm_state + 0x7efc, SMM_REVISION_ID);
1417 stl_phys(sm_state + 0x7f00, env->smbase);
1418 #else
1419 stl_phys(sm_state + 0x7ffc, env->cr[0]);
1420 stl_phys(sm_state + 0x7ff8, env->cr[3]);
1421 stl_phys(sm_state + 0x7ff4, compute_eflags());
1422 stl_phys(sm_state + 0x7ff0, env->eip);
1423 stl_phys(sm_state + 0x7fec, EDI);
1424 stl_phys(sm_state + 0x7fe8, ESI);
1425 stl_phys(sm_state + 0x7fe4, EBP);
1426 stl_phys(sm_state + 0x7fe0, ESP);
1427 stl_phys(sm_state + 0x7fdc, EBX);
1428 stl_phys(sm_state + 0x7fd8, EDX);
1429 stl_phys(sm_state + 0x7fd4, ECX);
1430 stl_phys(sm_state + 0x7fd0, EAX);
1431 stl_phys(sm_state + 0x7fcc, env->dr[6]);
1432 stl_phys(sm_state + 0x7fc8, env->dr[7]);
1433
1434 stl_phys(sm_state + 0x7fc4, env->tr.selector);
1435 stl_phys(sm_state + 0x7f64, env->tr.base);
1436 stl_phys(sm_state + 0x7f60, env->tr.limit);
1437 stl_phys(sm_state + 0x7f5c, (env->tr.flags >> 8) & 0xf0ff);
1438
1439 stl_phys(sm_state + 0x7fc0, env->ldt.selector);
1440 stl_phys(sm_state + 0x7f80, env->ldt.base);
1441 stl_phys(sm_state + 0x7f7c, env->ldt.limit);
1442 stl_phys(sm_state + 0x7f78, (env->ldt.flags >> 8) & 0xf0ff);
1443
1444 stl_phys(sm_state + 0x7f74, env->gdt.base);
1445 stl_phys(sm_state + 0x7f70, env->gdt.limit);
1446
1447 stl_phys(sm_state + 0x7f58, env->idt.base);
1448 stl_phys(sm_state + 0x7f54, env->idt.limit);
1449
1450 for(i = 0; i < 6; i++) {
1451 dt = &env->segs[i];
1452 if (i < 3)
1453 offset = 0x7f84 + i * 12;
1454 else
1455 offset = 0x7f2c + (i - 3) * 12;
1456 stl_phys(sm_state + 0x7fa8 + i * 4, dt->selector);
1457 stl_phys(sm_state + offset + 8, dt->base);
1458 stl_phys(sm_state + offset + 4, dt->limit);
1459 stl_phys(sm_state + offset, (dt->flags >> 8) & 0xf0ff);
1460 }
1461 stl_phys(sm_state + 0x7f14, env->cr[4]);
1462
1463 stl_phys(sm_state + 0x7efc, SMM_REVISION_ID);
1464 stl_phys(sm_state + 0x7ef8, env->smbase);
1465 #endif
1466 /* init SMM cpu state */
1467
1468 #ifdef TARGET_X86_64
1469 cpu_load_efer(env, 0);
1470 #endif
1471 load_eflags(0, ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1472 env->eip = 0x00008000;
1473 cpu_x86_load_seg_cache(env, R_CS, (env->smbase >> 4) & 0xffff, env->smbase,
1474 0xffffffff, 0);
1475 cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffffffff, 0);
1476 cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffffffff, 0);
1477 cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffffffff, 0);
1478 cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffffffff, 0);
1479 cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffffffff, 0);
1480
1481 cpu_x86_update_cr0(env,
1482 env->cr[0] & ~(CR0_PE_MASK | CR0_EM_MASK | CR0_TS_MASK | CR0_PG_MASK));
1483 cpu_x86_update_cr4(env, 0);
1484 env->dr[7] = 0x00000400;
1485 CC_OP = CC_OP_EFLAGS;
1486 }
1487
1488 void helper_rsm(void)
1489 {
1490 target_ulong sm_state;
1491 int i, offset;
1492 uint32_t val;
1493
1494 sm_state = env->smbase + 0x8000;
1495 #ifdef TARGET_X86_64
1496 cpu_load_efer(env, ldq_phys(sm_state + 0x7ed0));
1497
1498 for(i = 0; i < 6; i++) {
1499 offset = 0x7e00 + i * 16;
1500 cpu_x86_load_seg_cache(env, i,
1501 lduw_phys(sm_state + offset),
1502 ldq_phys(sm_state + offset + 8),
1503 ldl_phys(sm_state + offset + 4),
1504 (lduw_phys(sm_state + offset + 2) & 0xf0ff) << 8);
1505 }
1506
1507 env->gdt.base = ldq_phys(sm_state + 0x7e68);
1508 env->gdt.limit = ldl_phys(sm_state + 0x7e64);
1509
1510 env->ldt.selector = lduw_phys(sm_state + 0x7e70);
1511 env->ldt.base = ldq_phys(sm_state + 0x7e78);
1512 env->ldt.limit = ldl_phys(sm_state + 0x7e74);
1513 env->ldt.flags = (lduw_phys(sm_state + 0x7e72) & 0xf0ff) << 8;
1514
1515 env->idt.base = ldq_phys(sm_state + 0x7e88);
1516 env->idt.limit = ldl_phys(sm_state + 0x7e84);
1517
1518 env->tr.selector = lduw_phys(sm_state + 0x7e90);
1519 env->tr.base = ldq_phys(sm_state + 0x7e98);
1520 env->tr.limit = ldl_phys(sm_state + 0x7e94);
1521 env->tr.flags = (lduw_phys(sm_state + 0x7e92) & 0xf0ff) << 8;
1522
1523 EAX = ldq_phys(sm_state + 0x7ff8);
1524 ECX = ldq_phys(sm_state + 0x7ff0);
1525 EDX = ldq_phys(sm_state + 0x7fe8);
1526 EBX = ldq_phys(sm_state + 0x7fe0);
1527 ESP = ldq_phys(sm_state + 0x7fd8);
1528 EBP = ldq_phys(sm_state + 0x7fd0);
1529 ESI = ldq_phys(sm_state + 0x7fc8);
1530 EDI = ldq_phys(sm_state + 0x7fc0);
1531 for(i = 8; i < 16; i++)
1532 env->regs[i] = ldq_phys(sm_state + 0x7ff8 - i * 8);
1533 env->eip = ldq_phys(sm_state + 0x7f78);
1534 load_eflags(ldl_phys(sm_state + 0x7f70),
1535 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1536 env->dr[6] = ldl_phys(sm_state + 0x7f68);
1537 env->dr[7] = ldl_phys(sm_state + 0x7f60);
1538
1539 cpu_x86_update_cr4(env, ldl_phys(sm_state + 0x7f48));
1540 cpu_x86_update_cr3(env, ldl_phys(sm_state + 0x7f50));
1541 cpu_x86_update_cr0(env, ldl_phys(sm_state + 0x7f58));
1542
1543 val = ldl_phys(sm_state + 0x7efc); /* revision ID */
1544 if (val & 0x20000) {
1545 env->smbase = ldl_phys(sm_state + 0x7f00) & ~0x7fff;
1546 }
1547 #else
1548 cpu_x86_update_cr0(env, ldl_phys(sm_state + 0x7ffc));
1549 cpu_x86_update_cr3(env, ldl_phys(sm_state + 0x7ff8));
1550 load_eflags(ldl_phys(sm_state + 0x7ff4),
1551 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1552 env->eip = ldl_phys(sm_state + 0x7ff0);
1553 EDI = ldl_phys(sm_state + 0x7fec);
1554 ESI = ldl_phys(sm_state + 0x7fe8);
1555 EBP = ldl_phys(sm_state + 0x7fe4);
1556 ESP = ldl_phys(sm_state + 0x7fe0);
1557 EBX = ldl_phys(sm_state + 0x7fdc);
1558 EDX = ldl_phys(sm_state + 0x7fd8);
1559 ECX = ldl_phys(sm_state + 0x7fd4);
1560 EAX = ldl_phys(sm_state + 0x7fd0);
1561 env->dr[6] = ldl_phys(sm_state + 0x7fcc);
1562 env->dr[7] = ldl_phys(sm_state + 0x7fc8);
1563
1564 env->tr.selector = ldl_phys(sm_state + 0x7fc4) & 0xffff;
1565 env->tr.base = ldl_phys(sm_state + 0x7f64);
1566 env->tr.limit = ldl_phys(sm_state + 0x7f60);
1567 env->tr.flags = (ldl_phys(sm_state + 0x7f5c) & 0xf0ff) << 8;
1568
1569 env->ldt.selector = ldl_phys(sm_state + 0x7fc0) & 0xffff;
1570 env->ldt.base = ldl_phys(sm_state + 0x7f80);
1571 env->ldt.limit = ldl_phys(sm_state + 0x7f7c);
1572 env->ldt.flags = (ldl_phys(sm_state + 0x7f78) & 0xf0ff) << 8;
1573
1574 env->gdt.base = ldl_phys(sm_state + 0x7f74);
1575 env->gdt.limit = ldl_phys(sm_state + 0x7f70);
1576
1577 env->idt.base = ldl_phys(sm_state + 0x7f58);
1578 env->idt.limit = ldl_phys(sm_state + 0x7f54);
1579
1580 for(i = 0; i < 6; i++) {
1581 if (i < 3)
1582 offset = 0x7f84 + i * 12;
1583 else
1584 offset = 0x7f2c + (i - 3) * 12;
1585 cpu_x86_load_seg_cache(env, i,
1586 ldl_phys(sm_state + 0x7fa8 + i * 4) & 0xffff,
1587 ldl_phys(sm_state + offset + 8),
1588 ldl_phys(sm_state + offset + 4),
1589 (ldl_phys(sm_state + offset) & 0xf0ff) << 8);
1590 }
1591 cpu_x86_update_cr4(env, ldl_phys(sm_state + 0x7f14));
1592
1593 val = ldl_phys(sm_state + 0x7efc); /* revision ID */
1594 if (val & 0x20000) {
1595 env->smbase = ldl_phys(sm_state + 0x7ef8) & ~0x7fff;
1596 }
1597 #endif
1598 CC_OP = CC_OP_EFLAGS;
1599 env->hflags &= ~HF_SMM_MASK;
1600 cpu_smm_update(env);
1601
1602 qemu_log_mask(CPU_LOG_INT, "SMM: after RSM\n");
1603 log_cpu_state_mask(CPU_LOG_INT, env, X86_DUMP_CCOP);
1604 }
1605
1606 #endif /* !CONFIG_USER_ONLY */
1607
1608
1609 /* division, flags are undefined */
1610
1611 void helper_divb_AL(target_ulong t0)
1612 {
1613 unsigned int num, den, q, r;
1614
1615 num = (EAX & 0xffff);
1616 den = (t0 & 0xff);
1617 if (den == 0) {
1618 raise_exception(EXCP00_DIVZ);
1619 }
1620 q = (num / den);
1621 if (q > 0xff)
1622 raise_exception(EXCP00_DIVZ);
1623 q &= 0xff;
1624 r = (num % den) & 0xff;
1625 EAX = (EAX & ~0xffff) | (r << 8) | q;
1626 }
1627
1628 void helper_idivb_AL(target_ulong t0)
1629 {
1630 int num, den, q, r;
1631
1632 num = (int16_t)EAX;
1633 den = (int8_t)t0;
1634 if (den == 0) {
1635 raise_exception(EXCP00_DIVZ);
1636 }
1637 q = (num / den);
1638 if (q != (int8_t)q)
1639 raise_exception(EXCP00_DIVZ);
1640 q &= 0xff;
1641 r = (num % den) & 0xff;
1642 EAX = (EAX & ~0xffff) | (r << 8) | q;
1643 }
1644
1645 void helper_divw_AX(target_ulong t0)
1646 {
1647 unsigned int num, den, q, r;
1648
1649 num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
1650 den = (t0 & 0xffff);
1651 if (den == 0) {
1652 raise_exception(EXCP00_DIVZ);
1653 }
1654 q = (num / den);
1655 if (q > 0xffff)
1656 raise_exception(EXCP00_DIVZ);
1657 q &= 0xffff;
1658 r = (num % den) & 0xffff;
1659 EAX = (EAX & ~0xffff) | q;
1660 EDX = (EDX & ~0xffff) | r;
1661 }
1662
1663 void helper_idivw_AX(target_ulong t0)
1664 {
1665 int num, den, q, r;
1666
1667 num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
1668 den = (int16_t)t0;
1669 if (den == 0) {
1670 raise_exception(EXCP00_DIVZ);
1671 }
1672 q = (num / den);
1673 if (q != (int16_t)q)
1674 raise_exception(EXCP00_DIVZ);
1675 q &= 0xffff;
1676 r = (num % den) & 0xffff;
1677 EAX = (EAX & ~0xffff) | q;
1678 EDX = (EDX & ~0xffff) | r;
1679 }
1680
1681 void helper_divl_EAX(target_ulong t0)
1682 {
1683 unsigned int den, r;
1684 uint64_t num, q;
1685
1686 num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
1687 den = t0;
1688 if (den == 0) {
1689 raise_exception(EXCP00_DIVZ);
1690 }
1691 q = (num / den);
1692 r = (num % den);
1693 if (q > 0xffffffff)
1694 raise_exception(EXCP00_DIVZ);
1695 EAX = (uint32_t)q;
1696 EDX = (uint32_t)r;
1697 }
1698
1699 void helper_idivl_EAX(target_ulong t0)
1700 {
1701 int den, r;
1702 int64_t num, q;
1703
1704 num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
1705 den = t0;
1706 if (den == 0) {
1707 raise_exception(EXCP00_DIVZ);
1708 }
1709 q = (num / den);
1710 r = (num % den);
1711 if (q != (int32_t)q)
1712 raise_exception(EXCP00_DIVZ);
1713 EAX = (uint32_t)q;
1714 EDX = (uint32_t)r;
1715 }
1716
1717 /* bcd */
1718
1719 /* XXX: exception */
1720 void helper_aam(int base)
1721 {
1722 int al, ah;
1723 al = EAX & 0xff;
1724 ah = al / base;
1725 al = al % base;
1726 EAX = (EAX & ~0xffff) | al | (ah << 8);
1727 CC_DST = al;
1728 }
1729
1730 void helper_aad(int base)
1731 {
1732 int al, ah;
1733 al = EAX & 0xff;
1734 ah = (EAX >> 8) & 0xff;
1735 al = ((ah * base) + al) & 0xff;
1736 EAX = (EAX & ~0xffff) | al;
1737 CC_DST = al;
1738 }
1739
1740 void helper_aaa(void)
1741 {
1742 int icarry;
1743 int al, ah, af;
1744 int eflags;
1745
1746 eflags = helper_cc_compute_all(CC_OP);
1747 af = eflags & CC_A;
1748 al = EAX & 0xff;
1749 ah = (EAX >> 8) & 0xff;
1750
1751 icarry = (al > 0xf9);
1752 if (((al & 0x0f) > 9 ) || af) {
1753 al = (al + 6) & 0x0f;
1754 ah = (ah + 1 + icarry) & 0xff;
1755 eflags |= CC_C | CC_A;
1756 } else {
1757 eflags &= ~(CC_C | CC_A);
1758 al &= 0x0f;
1759 }
1760 EAX = (EAX & ~0xffff) | al | (ah << 8);
1761 CC_SRC = eflags;
1762 }
1763
1764 void helper_aas(void)
1765 {
1766 int icarry;
1767 int al, ah, af;
1768 int eflags;
1769
1770 eflags = helper_cc_compute_all(CC_OP);
1771 af = eflags & CC_A;
1772 al = EAX & 0xff;
1773 ah = (EAX >> 8) & 0xff;
1774
1775 icarry = (al < 6);
1776 if (((al & 0x0f) > 9 ) || af) {
1777 al = (al - 6) & 0x0f;
1778 ah = (ah - 1 - icarry) & 0xff;
1779 eflags |= CC_C | CC_A;
1780 } else {
1781 eflags &= ~(CC_C | CC_A);
1782 al &= 0x0f;
1783 }
1784 EAX = (EAX & ~0xffff) | al | (ah << 8);
1785 CC_SRC = eflags;
1786 }
1787
1788 void helper_daa(void)
1789 {
1790 int al, af, cf;
1791 int eflags;
1792
1793 eflags = helper_cc_compute_all(CC_OP);
1794 cf = eflags & CC_C;
1795 af = eflags & CC_A;
1796 al = EAX & 0xff;
1797
1798 eflags = 0;
1799 if (((al & 0x0f) > 9 ) || af) {
1800 al = (al + 6) & 0xff;
1801 eflags |= CC_A;
1802 }
1803 if ((al > 0x9f) || cf) {
1804 al = (al + 0x60) & 0xff;
1805 eflags |= CC_C;
1806 }
1807 EAX = (EAX & ~0xff) | al;
1808 /* well, speed is not an issue here, so we compute the flags by hand */
1809 eflags |= (al == 0) << 6; /* zf */
1810 eflags |= parity_table[al]; /* pf */
1811 eflags |= (al & 0x80); /* sf */
1812 CC_SRC = eflags;
1813 }
1814
1815 void helper_das(void)
1816 {
1817 int al, al1, af, cf;
1818 int eflags;
1819
1820 eflags = helper_cc_compute_all(CC_OP);
1821 cf = eflags & CC_C;
1822 af = eflags & CC_A;
1823 al = EAX & 0xff;
1824
1825 eflags = 0;
1826 al1 = al;
1827 if (((al & 0x0f) > 9 ) || af) {
1828 eflags |= CC_A;
1829 if (al < 6 || cf)
1830 eflags |= CC_C;
1831 al = (al - 6) & 0xff;
1832 }
1833 if ((al1 > 0x99) || cf) {
1834 al = (al - 0x60) & 0xff;
1835 eflags |= CC_C;
1836 }
1837 EAX = (EAX & ~0xff) | al;
1838 /* well, speed is not an issue here, so we compute the flags by hand */
1839 eflags |= (al == 0) << 6; /* zf */
1840 eflags |= parity_table[al]; /* pf */
1841 eflags |= (al & 0x80); /* sf */
1842 CC_SRC = eflags;
1843 }
1844
1845 void helper_into(int next_eip_addend)
1846 {
1847 int eflags;
1848 eflags = helper_cc_compute_all(CC_OP);
1849 if (eflags & CC_O) {
1850 raise_interrupt(EXCP04_INTO, 1, 0, next_eip_addend);
1851 }
1852 }
1853
1854 void helper_cmpxchg8b(target_ulong a0)
1855 {
1856 uint64_t d;
1857 int eflags;
1858
1859 eflags = helper_cc_compute_all(CC_OP);
1860 d = ldq(a0);
1861 if (d == (((uint64_t)EDX << 32) | (uint32_t)EAX)) {
1862 stq(a0, ((uint64_t)ECX << 32) | (uint32_t)EBX);
1863 eflags |= CC_Z;
1864 } else {
1865 /* always do the store */
1866 stq(a0, d);
1867 EDX = (uint32_t)(d >> 32);
1868 EAX = (uint32_t)d;
1869 eflags &= ~CC_Z;
1870 }
1871 CC_SRC = eflags;
1872 }
1873
1874 #ifdef TARGET_X86_64
1875 void helper_cmpxchg16b(target_ulong a0)
1876 {
1877 uint64_t d0, d1;
1878 int eflags;
1879
1880 if ((a0 & 0xf) != 0)
1881 raise_exception(EXCP0D_GPF);
1882 eflags = helper_cc_compute_all(CC_OP);
1883 d0 = ldq(a0);
1884 d1 = ldq(a0 + 8);
1885 if (d0 == EAX && d1 == EDX) {
1886 stq(a0, EBX);
1887 stq(a0 + 8, ECX);
1888 eflags |= CC_Z;
1889 } else {
1890 /* always do the store */
1891 stq(a0, d0);
1892 stq(a0 + 8, d1);
1893 EDX = d1;
1894 EAX = d0;
1895 eflags &= ~CC_Z;
1896 }
1897 CC_SRC = eflags;
1898 }
1899 #endif
1900
1901 void helper_single_step(void)
1902 {
1903 #ifndef CONFIG_USER_ONLY
1904 check_hw_breakpoints(env, 1);
1905 env->dr[6] |= DR6_BS;
1906 #endif
1907 raise_exception(EXCP01_DB);
1908 }
1909
1910 void helper_cpuid(void)
1911 {
1912 uint32_t eax, ebx, ecx, edx;
1913
1914 helper_svm_check_intercept_param(SVM_EXIT_CPUID, 0);
1915
1916 cpu_x86_cpuid(env, (uint32_t)EAX, (uint32_t)ECX, &eax, &ebx, &ecx, &edx);
1917 EAX = eax;
1918 EBX = ebx;
1919 ECX = ecx;
1920 EDX = edx;
1921 }
1922
1923 void helper_enter_level(int level, int data32, target_ulong t1)
1924 {
1925 target_ulong ssp;
1926 uint32_t esp_mask, esp, ebp;
1927
1928 esp_mask = get_sp_mask(env->segs[R_SS].flags);
1929 ssp = env->segs[R_SS].base;
1930 ebp = EBP;
1931 esp = ESP;
1932 if (data32) {
1933 /* 32 bit */
1934 esp -= 4;
1935 while (--level) {
1936 esp -= 4;
1937 ebp -= 4;
1938 stl(ssp + (esp & esp_mask), ldl(ssp + (ebp & esp_mask)));
1939 }
1940 esp -= 4;
1941 stl(ssp + (esp & esp_mask), t1);
1942 } else {
1943 /* 16 bit */
1944 esp -= 2;
1945 while (--level) {
1946 esp -= 2;
1947 ebp -= 2;
1948 stw(ssp + (esp & esp_mask), lduw(ssp + (ebp & esp_mask)));
1949 }
1950 esp -= 2;
1951 stw(ssp + (esp & esp_mask), t1);
1952 }
1953 }
1954
1955 #ifdef TARGET_X86_64
1956 void helper_enter64_level(int level, int data64, target_ulong t1)
1957 {
1958 target_ulong esp, ebp;
1959 ebp = EBP;
1960 esp = ESP;
1961
1962 if (data64) {
1963 /* 64 bit */
1964 esp -= 8;
1965 while (--level) {
1966 esp -= 8;
1967 ebp -= 8;
1968 stq(esp, ldq(ebp));
1969 }
1970 esp -= 8;
1971 stq(esp, t1);
1972 } else {
1973 /* 16 bit */
1974 esp -= 2;
1975 while (--level) {
1976 esp -= 2;
1977 ebp -= 2;
1978 stw(esp, lduw(ebp));
1979 }
1980 esp -= 2;
1981 stw(esp, t1);
1982 }
1983 }
1984 #endif
1985
1986 void helper_lldt(int selector)
1987 {
1988 SegmentCache *dt;
1989 uint32_t e1, e2;
1990 int index, entry_limit;
1991 target_ulong ptr;
1992
1993 selector &= 0xffff;
1994 if ((selector & 0xfffc) == 0) {
1995 /* XXX: NULL selector case: invalid LDT */
1996 env->ldt.base = 0;
1997 env->ldt.limit = 0;
1998 } else {
1999 if (selector & 0x4)
2000 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2001 dt = &env->gdt;
2002 index = selector & ~7;
2003 #ifdef TARGET_X86_64
2004 if (env->hflags & HF_LMA_MASK)
2005 entry_limit = 15;
2006 else
2007 #endif
2008 entry_limit = 7;
2009 if ((index + entry_limit) > dt->limit)
2010 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2011 ptr = dt->base + index;
2012 e1 = ldl_kernel(ptr);
2013 e2 = ldl_kernel(ptr + 4);
2014 if ((e2 & DESC_S_MASK) || ((e2 >> DESC_TYPE_SHIFT) & 0xf) != 2)
2015 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2016 if (!(e2 & DESC_P_MASK))
2017 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2018 #ifdef TARGET_X86_64
2019 if (env->hflags & HF_LMA_MASK) {
2020 uint32_t e3;
2021 e3 = ldl_kernel(ptr + 8);
2022 load_seg_cache_raw_dt(&env->ldt, e1, e2);
2023 env->ldt.base |= (target_ulong)e3 << 32;
2024 } else
2025 #endif
2026 {
2027 load_seg_cache_raw_dt(&env->ldt, e1, e2);
2028 }
2029 }
2030 env->ldt.selector = selector;
2031 }
2032
2033 void helper_ltr(int selector)
2034 {
2035 SegmentCache *dt;
2036 uint32_t e1, e2;
2037 int index, type, entry_limit;
2038 target_ulong ptr;
2039
2040 selector &= 0xffff;
2041 if ((selector & 0xfffc) == 0) {
2042 /* NULL selector case: invalid TR */
2043 env->tr.base = 0;
2044 env->tr.limit = 0;
2045 env->tr.flags = 0;
2046 } else {
2047 if (selector & 0x4)
2048 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2049 dt = &env->gdt;
2050 index = selector & ~7;
2051 #ifdef TARGET_X86_64
2052 if (env->hflags & HF_LMA_MASK)
2053 entry_limit = 15;
2054 else
2055 #endif
2056 entry_limit = 7;
2057 if ((index + entry_limit) > dt->limit)
2058 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2059 ptr = dt->base + index;
2060 e1 = ldl_kernel(ptr);
2061 e2 = ldl_kernel(ptr + 4);
2062 type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
2063 if ((e2 & DESC_S_MASK) ||
2064 (type != 1 && type != 9))
2065 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2066 if (!(e2 & DESC_P_MASK))
2067 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2068 #ifdef TARGET_X86_64
2069 if (env->hflags & HF_LMA_MASK) {
2070 uint32_t e3, e4;
2071 e3 = ldl_kernel(ptr + 8);
2072 e4 = ldl_kernel(ptr + 12);
2073 if ((e4 >> DESC_TYPE_SHIFT) & 0xf)
2074 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2075 load_seg_cache_raw_dt(&env->tr, e1, e2);
2076 env->tr.base |= (target_ulong)e3 << 32;
2077 } else
2078 #endif
2079 {
2080 load_seg_cache_raw_dt(&env->tr, e1, e2);
2081 }
2082 e2 |= DESC_TSS_BUSY_MASK;
2083 stl_kernel(ptr + 4, e2);
2084 }
2085 env->tr.selector = selector;
2086 }
2087
2088 /* only works if protected mode and not VM86. seg_reg must be != R_CS */
2089 void helper_load_seg(int seg_reg, int selector)
2090 {
2091 uint32_t e1, e2;
2092 int cpl, dpl, rpl;
2093 SegmentCache *dt;
2094 int index;
2095 target_ulong ptr;
2096
2097 selector &= 0xffff;
2098 cpl = env->hflags & HF_CPL_MASK;
2099 if ((selector & 0xfffc) == 0) {
2100 /* null selector case */
2101 if (seg_reg == R_SS
2102 #ifdef TARGET_X86_64
2103 && (!(env->hflags & HF_CS64_MASK) || cpl == 3)
2104 #endif
2105 )
2106 raise_exception_err(EXCP0D_GPF, 0);
2107 cpu_x86_load_seg_cache(env, seg_reg, selector, 0, 0, 0);
2108 } else {
2109
2110 if (selector & 0x4)
2111 dt = &env->ldt;
2112 else
2113 dt = &env->gdt;
2114 index = selector & ~7;
2115 if ((index + 7) > dt->limit)
2116 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2117 ptr = dt->base + index;
2118 e1 = ldl_kernel(ptr);
2119 e2 = ldl_kernel(ptr + 4);
2120
2121 if (!(e2 & DESC_S_MASK))
2122 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2123 rpl = selector & 3;
2124 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2125 if (seg_reg == R_SS) {
2126 /* must be writable segment */
2127 if ((e2 & DESC_CS_MASK) || !(e2 & DESC_W_MASK))
2128 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2129 if (rpl != cpl || dpl != cpl)
2130 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2131 } else {
2132 /* must be readable segment */
2133 if ((e2 & (DESC_CS_MASK | DESC_R_MASK)) == DESC_CS_MASK)
2134 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2135
2136 if (!(e2 & DESC_CS_MASK) || !(e2 & DESC_C_MASK)) {
2137 /* if not conforming code, test rights */
2138 if (dpl < cpl || dpl < rpl)
2139 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2140 }
2141 }
2142
2143 if (!(e2 & DESC_P_MASK)) {
2144 if (seg_reg == R_SS)
2145 raise_exception_err(EXCP0C_STACK, selector & 0xfffc);
2146 else
2147 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2148 }
2149
2150 /* set the access bit if not already set */
2151 if (!(e2 & DESC_A_MASK)) {
2152 e2 |= DESC_A_MASK;
2153 stl_kernel(ptr + 4, e2);
2154 }
2155
2156 cpu_x86_load_seg_cache(env, seg_reg, selector,
2157 get_seg_base(e1, e2),
2158 get_seg_limit(e1, e2),
2159 e2);
2160 #if 0
2161 qemu_log("load_seg: sel=0x%04x base=0x%08lx limit=0x%08lx flags=%08x\n",
2162 selector, (unsigned long)sc->base, sc->limit, sc->flags);
2163 #endif
2164 }
2165 }
2166
2167 /* protected mode jump */
2168 void helper_ljmp_protected(int new_cs, target_ulong new_eip,
2169 int next_eip_addend)
2170 {
2171 int gate_cs, type;
2172 uint32_t e1, e2, cpl, dpl, rpl, limit;
2173 target_ulong next_eip;
2174
2175 if ((new_cs & 0xfffc) == 0)
2176 raise_exception_err(EXCP0D_GPF, 0);
2177 if (load_segment(&e1, &e2, new_cs) != 0)
2178 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2179 cpl = env->hflags & HF_CPL_MASK;
2180 if (e2 & DESC_S_MASK) {
2181 if (!(e2 & DESC_CS_MASK))
2182 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2183 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2184 if (e2 & DESC_C_MASK) {
2185 /* conforming code segment */
2186 if (dpl > cpl)
2187 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2188 } else {
2189 /* non conforming code segment */
2190 rpl = new_cs & 3;
2191 if (rpl > cpl)
2192 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2193 if (dpl != cpl)
2194 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2195 }
2196 if (!(e2 & DESC_P_MASK))
2197 raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2198 limit = get_seg_limit(e1, e2);
2199 if (new_eip > limit &&
2200 !(env->hflags & HF_LMA_MASK) && !(e2 & DESC_L_MASK))
2201 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2202 cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2203 get_seg_base(e1, e2), limit, e2);
2204 EIP = new_eip;
2205 } else {
2206 /* jump to call or task gate */
2207 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2208 rpl = new_cs & 3;
2209 cpl = env->hflags & HF_CPL_MASK;
2210 type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
2211 switch(type) {
2212 case 1: /* 286 TSS */
2213 case 9: /* 386 TSS */
2214 case 5: /* task gate */
2215 if (dpl < cpl || dpl < rpl)
2216 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2217 next_eip = env->eip + next_eip_addend;
2218 switch_tss(new_cs, e1, e2, SWITCH_TSS_JMP, next_eip);
2219 CC_OP = CC_OP_EFLAGS;
2220 break;
2221 case 4: /* 286 call gate */
2222 case 12: /* 386 call gate */
2223 if ((dpl < cpl) || (dpl < rpl))
2224 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2225 if (!(e2 & DESC_P_MASK))
2226 raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2227 gate_cs = e1 >> 16;
2228 new_eip = (e1 & 0xffff);
2229 if (type == 12)
2230 new_eip |= (e2 & 0xffff0000);
2231 if (load_segment(&e1, &e2, gate_cs) != 0)
2232 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2233 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2234 /* must be code segment */
2235 if (((e2 & (DESC_S_MASK | DESC_CS_MASK)) !=
2236 (DESC_S_MASK | DESC_CS_MASK)))
2237 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2238 if (((e2 & DESC_C_MASK) && (dpl > cpl)) ||
2239 (!(e2 & DESC_C_MASK) && (dpl != cpl)))
2240 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2241 if (!(e2 & DESC_P_MASK))
2242 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2243 limit = get_seg_limit(e1, e2);
2244 if (new_eip > limit)
2245 raise_exception_err(EXCP0D_GPF, 0);
2246 cpu_x86_load_seg_cache(env, R_CS, (gate_cs & 0xfffc) | cpl,
2247 get_seg_base(e1, e2), limit, e2);
2248 EIP = new_eip;
2249 break;
2250 default:
2251 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2252 break;
2253 }
2254 }
2255 }
2256
2257 /* real mode call */
2258 void helper_lcall_real(int new_cs, target_ulong new_eip1,
2259 int shift, int next_eip)
2260 {
2261 int new_eip;
2262 uint32_t esp, esp_mask;
2263 target_ulong ssp;
2264
2265 new_eip = new_eip1;
2266 esp = ESP;
2267 esp_mask = get_sp_mask(env->segs[R_SS].flags);
2268 ssp = env->segs[R_SS].base;
2269 if (shift) {
2270 PUSHL(ssp, esp, esp_mask, env->segs[R_CS].selector);
2271 PUSHL(ssp, esp, esp_mask, next_eip);
2272 } else {
2273 PUSHW(ssp, esp, esp_mask, env->segs[R_CS].selector);
2274 PUSHW(ssp, esp, esp_mask, next_eip);
2275 }
2276
2277 SET_ESP(esp, esp_mask);
2278 env->eip = new_eip;
2279 env->segs[R_CS].selector = new_cs;
2280 env->segs[R_CS].base = (new_cs << 4);
2281 }
2282
2283 /* protected mode call */
2284 void helper_lcall_protected(int new_cs, target_ulong new_eip,
2285 int shift, int next_eip_addend)
2286 {
2287 int new_stack, i;
2288 uint32_t e1, e2, cpl, dpl, rpl, selector, offset, param_count;
2289 uint32_t ss = 0, ss_e1 = 0, ss_e2 = 0, sp, type, ss_dpl, sp_mask;
2290 uint32_t val, limit, old_sp_mask;
2291 target_ulong ssp, old_ssp, next_eip;
2292
2293 next_eip = env->eip + next_eip_addend;
2294 LOG_PCALL("lcall %04x:%08x s=%d\n", new_cs, (uint32_t)new_eip, shift);
2295 LOG_PCALL_STATE(env);
2296 if ((new_cs & 0xfffc) == 0)
2297 raise_exception_err(EXCP0D_GPF, 0);
2298 if (load_segment(&e1, &e2, new_cs) != 0)
2299 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2300 cpl = env->hflags & HF_CPL_MASK;
2301 LOG_PCALL("desc=%08x:%08x\n", e1, e2);
2302 if (e2 & DESC_S_MASK) {
2303 if (!(e2 & DESC_CS_MASK))
2304 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2305 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2306 if (e2 & DESC_C_MASK) {
2307 /* conforming code segment */
2308 if (dpl > cpl)
2309 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2310 } else {
2311 /* non conforming code segment */
2312 rpl = new_cs & 3;
2313 if (rpl > cpl)
2314 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2315 if (dpl != cpl)
2316 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2317 }
2318 if (!(e2 & DESC_P_MASK))
2319 raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2320
2321 #ifdef TARGET_X86_64
2322 /* XXX: check 16/32 bit cases in long mode */
2323 if (shift == 2) {
2324 target_ulong rsp;
2325 /* 64 bit case */
2326 rsp = ESP;
2327 PUSHQ(rsp, env->segs[R_CS].selector);
2328 PUSHQ(rsp, next_eip);
2329 /* from this point, not restartable */
2330 ESP = rsp;
2331 cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2332 get_seg_base(e1, e2),
2333 get_seg_limit(e1, e2), e2);
2334 EIP = new_eip;
2335 } else
2336 #endif
2337 {
2338 sp = ESP;
2339 sp_mask = get_sp_mask(env->segs[R_SS].flags);
2340 ssp = env->segs[R_SS].base;
2341 if (shift) {
2342 PUSHL(ssp, sp, sp_mask, env->segs[R_CS].selector);
2343 PUSHL(ssp, sp, sp_mask, next_eip);
2344 } else {
2345 PUSHW(ssp, sp, sp_mask, env->segs[R_CS].selector);
2346 PUSHW(ssp, sp, sp_mask, next_eip);
2347 }
2348
2349 limit = get_seg_limit(e1, e2);
2350 if (new_eip > limit)
2351 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2352 /* from this point, not restartable */
2353 SET_ESP(sp, sp_mask);
2354 cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2355 get_seg_base(e1, e2), limit, e2);
2356 EIP = new_eip;
2357 }
2358 } else {
2359 /* check gate type */
2360 type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;
2361 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2362 rpl = new_cs & 3;
2363 switch(type) {
2364 case 1: /* available 286 TSS */
2365 case 9: /* available 386 TSS */
2366 case 5: /* task gate */
2367 if (dpl < cpl || dpl < rpl)
2368 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2369 switch_tss(new_cs, e1, e2, SWITCH_TSS_CALL, next_eip);
2370 CC_OP = CC_OP_EFLAGS;
2371 return;
2372 case 4: /* 286 call gate */
2373 case 12: /* 386 call gate */
2374 break;
2375 default:
2376 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2377 break;
2378 }
2379 shift = type >> 3;
2380
2381 if (dpl < cpl || dpl < rpl)
2382 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2383 /* check valid bit */
2384 if (!(e2 & DESC_P_MASK))
2385 raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2386 selector = e1 >> 16;
2387 offset = (e2 & 0xffff0000) | (e1 & 0x0000ffff);
2388 param_count = e2 & 0x1f;
2389 if ((selector & 0xfffc) == 0)
2390 raise_exception_err(EXCP0D_GPF, 0);
2391
2392 if (load_segment(&e1, &e2, selector) != 0)
2393 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2394 if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))
2395 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2396 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2397 if (dpl > cpl)
2398 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2399 if (!(e2 & DESC_P_MASK))
2400 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2401
2402 if (!(e2 & DESC_C_MASK) && dpl < cpl) {
2403 /* to inner privilege */
2404 get_ss_esp_from_tss(&ss, &sp, dpl);
2405 LOG_PCALL("new ss:esp=%04x:%08x param_count=%d ESP=" TARGET_FMT_lx "\n",
2406 ss, sp, param_count, ESP);
2407 if ((ss & 0xfffc) == 0)
2408 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2409 if ((ss & 3) != dpl)
2410 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2411 if (load_segment(&ss_e1, &ss_e2, ss) != 0)
2412 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2413 ss_dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
2414 if (ss_dpl != dpl)
2415 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2416 if (!(ss_e2 & DESC_S_MASK) ||
2417 (ss_e2 & DESC_CS_MASK) ||
2418 !(ss_e2 & DESC_W_MASK))
2419 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2420 if (!(ss_e2 & DESC_P_MASK))
2421 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2422
2423 // push_size = ((param_count * 2) + 8) << shift;
2424
2425 old_sp_mask = get_sp_mask(env->segs[R_SS].flags);
2426 old_ssp = env->segs[R_SS].base;
2427
2428 sp_mask = get_sp_mask(ss_e2);
2429 ssp = get_seg_base(ss_e1, ss_e2);
2430 if (shift) {
2431 PUSHL(ssp, sp, sp_mask, env->segs[R_SS].selector);
2432 PUSHL(ssp, sp, sp_mask, ESP);
2433 for(i = param_count - 1; i >= 0; i--) {
2434 val = ldl_kernel(old_ssp + ((ESP + i * 4) & old_sp_mask));
2435 PUSHL(ssp, sp, sp_mask, val);
2436 }
2437 } else {
2438 PUSHW(ssp, sp, sp_mask, env->segs[R_SS].selector);
2439 PUSHW(ssp, sp, sp_mask, ESP);
2440 for(i = param_count - 1; i >= 0; i--) {
2441 val = lduw_kernel(old_ssp + ((ESP + i * 2) & old_sp_mask));
2442 PUSHW(ssp, sp, sp_mask, val);
2443 }
2444 }
2445 new_stack = 1;
2446 } else {
2447 /* to same privilege */
2448 sp = ESP;
2449 sp_mask = get_sp_mask(env->segs[R_SS].flags);
2450 ssp = env->segs[R_SS].base;
2451 // push_size = (4 << shift);
2452 new_stack = 0;
2453 }
2454
2455 if (shift) {
2456 PUSHL(ssp, sp, sp_mask, env->segs[R_CS].selector);
2457 PUSHL(ssp, sp, sp_mask, next_eip);
2458 } else {
2459 PUSHW(ssp, sp, sp_mask, env->segs[R_CS].selector);
2460 PUSHW(ssp, sp, sp_mask, next_eip);
2461 }
2462
2463 /* from this point, not restartable */
2464
2465 if (new_stack) {
2466 ss = (ss & ~3) | dpl;
2467 cpu_x86_load_seg_cache(env, R_SS, ss,
2468 ssp,
2469 get_seg_limit(ss_e1, ss_e2),
2470 ss_e2);
2471 }
2472
2473 selector = (selector & ~3) | dpl;
2474 cpu_x86_load_seg_cache(env, R_CS, selector,
2475 get_seg_base(e1, e2),
2476 get_seg_limit(e1, e2),
2477 e2);
2478 cpu_x86_set_cpl(env, dpl);
2479 SET_ESP(sp, sp_mask);
2480 EIP = offset;
2481 }
2482 #ifdef USE_KQEMU
2483 if (kqemu_is_ok(env)) {
2484 env->exception_index = -1;
2485 cpu_loop_exit();
2486 }
2487 #endif
2488 }
2489
2490 /* real and vm86 mode iret */
2491 void helper_iret_real(int shift)
2492 {
2493 uint32_t sp, new_cs, new_eip, new_eflags, sp_mask;
2494 target_ulong ssp;
2495 int eflags_mask;
2496
2497 sp_mask = 0xffff; /* XXXX: use SS segment size ? */
2498 sp = ESP;
2499 ssp = env->segs[R_SS].base;
2500 if (shift == 1) {
2501 /* 32 bits */
2502 POPL(ssp, sp, sp_mask, new_eip);
2503 POPL(ssp, sp, sp_mask, new_cs);
2504 new_cs &= 0xffff;
2505 POPL(ssp, sp, sp_mask, new_eflags);
2506 } else {
2507 /* 16 bits */
2508 POPW(ssp, sp, sp_mask, new_eip);
2509 POPW(ssp, sp, sp_mask, new_cs);
2510 POPW(ssp, sp, sp_mask, new_eflags);
2511 }
2512 ESP = (ESP & ~sp_mask) | (sp & sp_mask);
2513 env->segs[R_CS].selector = new_cs;
2514 env->segs[R_CS].base = (new_cs << 4);
2515 env->eip = new_eip;
2516 if (env->eflags & VM_MASK)
2517 eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | RF_MASK | NT_MASK;
2518 else
2519 eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | IOPL_MASK | RF_MASK | NT_MASK;
2520 if (shift == 0)
2521 eflags_mask &= 0xffff;
2522 load_eflags(new_eflags, eflags_mask);
2523 env->hflags2 &= ~HF2_NMI_MASK;
2524 }
2525
2526 static inline void validate_seg(int seg_reg, int cpl)
2527 {
2528 int dpl;
2529 uint32_t e2;
2530
2531 /* XXX: on x86_64, we do not want to nullify FS and GS because
2532 they may still contain a valid base. I would be interested to
2533 know how a real x86_64 CPU behaves */
2534 if ((seg_reg == R_FS || seg_reg == R_GS) &&
2535 (env->segs[seg_reg].selector & 0xfffc) == 0)
2536 return;
2537
2538 e2 = env->segs[seg_reg].flags;
2539 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2540 if (!(e2 & DESC_CS_MASK) || !(e2 & DESC_C_MASK)) {
2541 /* data or non conforming code segment */
2542 if (dpl < cpl) {
2543 cpu_x86_load_seg_cache(env, seg_reg, 0, 0, 0, 0);
2544 }
2545 }
2546 }
2547
2548 /* protected mode iret */
2549 static inline void helper_ret_protected(int shift, int is_iret, int addend)
2550 {
2551 uint32_t new_cs, new_eflags, new_ss;
2552 uint32_t new_es, new_ds, new_fs, new_gs;
2553 uint32_t e1, e2, ss_e1, ss_e2;
2554 int cpl, dpl, rpl, eflags_mask, iopl;
2555 target_ulong ssp, sp, new_eip, new_esp, sp_mask;
2556
2557 #ifdef TARGET_X86_64
2558 if (shift == 2)
2559 sp_mask = -1;
2560 else
2561 #endif
2562 sp_mask = get_sp_mask(env->segs[R_SS].flags);
2563 sp = ESP;
2564 ssp = env->segs[R_SS].base;
2565 new_eflags = 0; /* avoid warning */
2566 #ifdef TARGET_X86_64
2567 if (shift == 2) {
2568 POPQ(sp, new_eip);
2569 POPQ(sp, new_cs);
2570 new_cs &= 0xffff;
2571 if (is_iret) {
2572 POPQ(sp, new_eflags);
2573 }
2574 } else
2575 #endif
2576 if (shift == 1) {
2577 /* 32 bits */
2578 POPL(ssp, sp, sp_mask, new_eip);
2579 POPL(ssp, sp, sp_mask, new_cs);
2580 new_cs &= 0xffff;
2581 if (is_iret) {
2582 POPL(ssp, sp, sp_mask, new_eflags);
2583 if (new_eflags & VM_MASK)
2584 goto return_to_vm86;
2585 }
2586 } else {
2587 /* 16 bits */
2588 POPW(ssp, sp, sp_mask, new_eip);
2589 POPW(ssp, sp, sp_mask, new_cs);
2590 if (is_iret)
2591 POPW(ssp, sp, sp_mask, new_eflags);
2592 }
2593 LOG_PCALL("lret new %04x:" TARGET_FMT_lx " s=%d addend=0x%x\n",
2594 new_cs, new_eip, shift, addend);
2595 LOG_PCALL_STATE(env);
2596 if ((new_cs & 0xfffc) == 0)
2597 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2598 if (load_segment(&e1, &e2, new_cs) != 0)
2599 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2600 if (!(e2 & DESC_S_MASK) ||
2601 !(e2 & DESC_CS_MASK))
2602 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2603 cpl = env->hflags & HF_CPL_MASK;
2604 rpl = new_cs & 3;
2605 if (rpl < cpl)
2606 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2607 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2608 if (e2 & DESC_C_MASK) {
2609 if (dpl > rpl)
2610 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2611 } else {
2612 if (dpl != rpl)
2613 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2614 }
2615 if (!(e2 & DESC_P_MASK))
2616 raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2617
2618 sp += addend;
2619 if (rpl == cpl && (!(env->hflags & HF_CS64_MASK) ||
2620 ((env->hflags & HF_CS64_MASK) && !is_iret))) {
2621 /* return to same privilege level */
2622 cpu_x86_load_seg_cache(env, R_CS, new_cs,
2623 get_seg_base(e1, e2),
2624 get_seg_limit(e1, e2),
2625 e2);
2626 } else {
2627 /* return to different privilege level */
2628 #ifdef TARGET_X86_64
2629 if (shift == 2) {
2630 POPQ(sp, new_esp);
2631 POPQ(sp, new_ss);
2632 new_ss &= 0xffff;
2633 } else
2634 #endif
2635 if (shift == 1) {
2636 /* 32 bits */
2637 POPL(ssp, sp, sp_mask, new_esp);
2638 POPL(ssp, sp, sp_mask, new_ss);
2639 new_ss &= 0xffff;
2640 } else {
2641 /* 16 bits */
2642 POPW(ssp, sp, sp_mask, new_esp);
2643 POPW(ssp, sp, sp_mask, new_ss);
2644 }
2645 LOG_PCALL("new ss:esp=%04x:" TARGET_FMT_lx "\n",
2646 new_ss, new_esp);
2647 if ((new_ss & 0xfffc) == 0) {
2648 #ifdef TARGET_X86_64
2649 /* NULL ss is allowed in long mode if cpl != 3*/
2650 /* XXX: test CS64 ? */
2651 if ((env->hflags & HF_LMA_MASK) && rpl != 3) {
2652 cpu_x86_load_seg_cache(env, R_SS, new_ss,
2653 0, 0xffffffff,
2654 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2655 DESC_S_MASK | (rpl << DESC_DPL_SHIFT) |
2656 DESC_W_MASK | DESC_A_MASK);
2657 ss_e2 = DESC_B_MASK; /* XXX: should not be needed ? */
2658 } else
2659 #endif
2660 {
2661 raise_exception_err(EXCP0D_GPF, 0);
2662 }
2663 } else {
2664 if ((new_ss & 3) != rpl)
2665 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2666 if (load_segment(&ss_e1, &ss_e2, new_ss) != 0)
2667 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2668 if (!(ss_e2 & DESC_S_MASK) ||
2669 (ss_e2 & DESC_CS_MASK) ||
2670 !(ss_e2 & DESC_W_MASK))
2671 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2672 dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
2673 if (dpl != rpl)
2674 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2675 if (!(ss_e2 & DESC_P_MASK))
2676 raise_exception_err(EXCP0B_NOSEG, new_ss & 0xfffc);
2677 cpu_x86_load_seg_cache(env, R_SS, new_ss,
2678 get_seg_base(ss_e1, ss_e2),
2679 get_seg_limit(ss_e1, ss_e2),
2680 ss_e2);
2681 }
2682
2683 cpu_x86_load_seg_cache(env, R_CS, new_cs,
2684 get_seg_base(e1, e2),
2685 get_seg_limit(e1, e2),
2686 e2);
2687 cpu_x86_set_cpl(env, rpl);
2688 sp = new_esp;
2689 #ifdef TARGET_X86_64
2690 if (env->hflags & HF_CS64_MASK)
2691 sp_mask = -1;
2692 else
2693 #endif
2694 sp_mask = get_sp_mask(ss_e2);
2695
2696 /* validate data segments */
2697 validate_seg(R_ES, rpl);
2698 validate_seg(R_DS, rpl);
2699 validate_seg(R_FS, rpl);
2700 validate_seg(R_GS, rpl);
2701
2702 sp += addend;
2703 }
2704 SET_ESP(sp, sp_mask);
2705 env->eip = new_eip;
2706 if (is_iret) {
2707 /* NOTE: 'cpl' is the _old_ CPL */
2708 eflags_mask = TF_MASK | AC_MASK | ID_MASK | RF_MASK | NT_MASK;
2709 if (cpl == 0)
2710 eflags_mask |= IOPL_MASK;
2711 iopl = (env->eflags >> IOPL_SHIFT) & 3;
2712 if (cpl <= iopl)
2713 eflags_mask |= IF_MASK;
2714 if (shift == 0)
2715 eflags_mask &= 0xffff;
2716 load_eflags(new_eflags, eflags_mask);
2717 }
2718 return;
2719
2720 return_to_vm86:
2721 POPL(ssp, sp, sp_mask, new_esp);
2722 POPL(ssp, sp, sp_mask, new_ss);
2723 POPL(ssp, sp, sp_mask, new_es);
2724 POPL(ssp, sp, sp_mask, new_ds);
2725 POPL(ssp, sp, sp_mask, new_fs);
2726 POPL(ssp, sp, sp_mask, new_gs);
2727
2728 /* modify processor state */
2729 load_eflags(new_eflags, TF_MASK | AC_MASK | ID_MASK |
2730 IF_MASK | IOPL_MASK | VM_MASK | NT_MASK | VIF_MASK | VIP_MASK);
2731 load_seg_vm(R_CS, new_cs & 0xffff);
2732 cpu_x86_set_cpl(env, 3);
2733 load_seg_vm(R_SS, new_ss & 0xffff);
2734 load_seg_vm(R_ES, new_es & 0xffff);
2735 load_seg_vm(R_DS, new_ds & 0xffff);
2736 load_seg_vm(R_FS, new_fs & 0xffff);
2737 load_seg_vm(R_GS, new_gs & 0xffff);
2738
2739 env->eip = new_eip & 0xffff;
2740 ESP = new_esp;
2741 }
2742
2743 void helper_iret_protected(int shift, int next_eip)
2744 {
2745 int tss_selector, type;
2746 uint32_t e1, e2;
2747
2748 /* specific case for TSS */
2749 if (env->eflags & NT_MASK) {
2750 #ifdef TARGET_X86_64
2751 if (env->hflags & HF_LMA_MASK)
2752 raise_exception_err(EXCP0D_GPF, 0);
2753 #endif
2754 tss_selector = lduw_kernel(env->tr.base + 0);
2755 if (tss_selector & 4)
2756 raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2757 if (load_segment(&e1, &e2, tss_selector) != 0)
2758 raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2759 type = (e2 >> DESC_TYPE_SHIFT) & 0x17;
2760 /* NOTE: we check both segment and busy TSS */
2761 if (type != 3)
2762 raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2763 switch_tss(tss_selector, e1, e2, SWITCH_TSS_IRET, next_eip);
2764 } else {
2765 helper_ret_protected(shift, 1, 0);
2766 }
2767 env->hflags2 &= ~HF2_NMI_MASK;
2768 #ifdef USE_KQEMU
2769 if (kqemu_is_ok(env)) {
2770 CC_OP = CC_OP_EFLAGS;
2771 env->exception_index = -1;
2772 cpu_loop_exit();
2773 }
2774 #endif
2775 }
2776
2777 void helper_lret_protected(int shift, int addend)
2778 {
2779 helper_ret_protected(shift, 0, addend);
2780 #ifdef USE_KQEMU
2781 if (kqemu_is_ok(env)) {
2782 env->exception_index = -1;
2783 cpu_loop_exit();
2784 }
2785 #endif
2786 }
2787
2788 void helper_sysenter(void)
2789 {
2790 if (env->sysenter_cs == 0) {
2791 raise_exception_err(EXCP0D_GPF, 0);
2792 }
2793 env->eflags &= ~(VM_MASK | IF_MASK | RF_MASK);
2794 cpu_x86_set_cpl(env, 0);
2795
2796 #ifdef TARGET_X86_64
2797 if (env->hflags & HF_LMA_MASK) {
2798 cpu_x86_load_seg_cache(env, R_CS, env->sysenter_cs & 0xfffc,
2799 0, 0xffffffff,
2800 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2801 DESC_S_MASK |
2802 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
2803 } else
2804 #endif
2805 {
2806 cpu_x86_load_seg_cache(env, R_CS, env->sysenter_cs & 0xfffc,
2807 0, 0xffffffff,
2808 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2809 DESC_S_MASK |
2810 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
2811 }
2812 cpu_x86_load_seg_cache(env, R_SS, (env->sysenter_cs + 8) & 0xfffc,
2813 0, 0xffffffff,
2814 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2815 DESC_S_MASK |
2816 DESC_W_MASK | DESC_A_MASK);
2817 ESP = env->sysenter_esp;
2818 EIP = env->sysenter_eip;
2819 }
2820
2821 void helper_sysexit(int dflag)
2822 {
2823 int cpl;
2824
2825 cpl = env->hflags & HF_CPL_MASK;
2826 if (env->sysenter_cs == 0 || cpl != 0) {
2827 raise_exception_err(EXCP0D_GPF, 0);
2828 }
2829 cpu_x86_set_cpl(env, 3);
2830 #ifdef TARGET_X86_64
2831 if (dflag == 2) {
2832 cpu_x86_load_seg_cache(env, R_CS, ((env->sysenter_cs + 32) & 0xfffc) | 3,
2833 0, 0xffffffff,
2834 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2835 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2836 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
2837 cpu_x86_load_seg_cache(env, R_SS, ((env->sysenter_cs + 40) & 0xfffc) | 3,
2838 0, 0xffffffff,
2839 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2840 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2841 DESC_W_MASK | DESC_A_MASK);
2842 } else
2843 #endif
2844 {
2845 cpu_x86_load_seg_cache(env, R_CS, ((env->sysenter_cs + 16) & 0xfffc) | 3,
2846 0, 0xffffffff,
2847 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2848 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2849 DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
2850 cpu_x86_load_seg_cache(env, R_SS, ((env->sysenter_cs + 24) & 0xfffc) | 3,
2851 0, 0xffffffff,
2852 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2853 DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2854 DESC_W_MASK | DESC_A_MASK);
2855 }
2856 ESP = ECX;
2857 EIP = EDX;
2858 #ifdef USE_KQEMU
2859 if (kqemu_is_ok(env)) {
2860 env->exception_index = -1;
2861 cpu_loop_exit();
2862 }
2863 #endif
2864 }
2865
2866 #if defined(CONFIG_USER_ONLY)
2867 target_ulong helper_read_crN(int reg)
2868 {
2869 return 0;
2870 }
2871
2872 void helper_write_crN(int reg, target_ulong t0)
2873 {
2874 }
2875
2876 void helper_movl_drN_T0(int reg, target_ulong t0)
2877 {
2878 }
2879 #else
2880 target_ulong helper_read_crN(int reg)
2881 {
2882 target_ulong val;
2883
2884 helper_svm_check_intercept_param(SVM_EXIT_READ_CR0 + reg, 0);
2885 switch(reg) {
2886 default:
2887 val = env->cr[reg];
2888 break;
2889 case 8:
2890 if (!(env->hflags2 & HF2_VINTR_MASK)) {
2891 val = cpu_get_apic_tpr(env);
2892 } else {
2893 val = env->v_tpr;
2894 }
2895 break;
2896 }
2897 return val;
2898 }
2899
2900 void helper_write_crN(int reg, target_ulong t0)
2901 {
2902 helper_svm_check_intercept_param(SVM_EXIT_WRITE_CR0 + reg, 0);
2903 switch(reg) {
2904 case 0:
2905 cpu_x86_update_cr0(env, t0);
2906 break;
2907 case 3:
2908 cpu_x86_update_cr3(env, t0);
2909 break;
2910 case 4:
2911 cpu_x86_update_cr4(env, t0);
2912 break;
2913 case 8:
2914 if (!(env->hflags2 & HF2_VINTR_MASK)) {
2915 cpu_set_apic_tpr(env, t0);
2916 }
2917 env->v_tpr = t0 & 0x0f;
2918 break;
2919 default:
2920 env->cr[reg] = t0;
2921 break;
2922 }
2923 }
2924
2925 void helper_movl_drN_T0(int reg, target_ulong t0)
2926 {
2927 int i;
2928
2929 if (reg < 4) {
2930 hw_breakpoint_remove(env, reg);
2931 env->dr[reg] = t0;
2932 hw_breakpoint_insert(env, reg);
2933 } else if (reg == 7) {
2934 for (i = 0; i < 4; i++)
2935 hw_breakpoint_remove(env, i);
2936 env->dr[7] = t0;
2937 for (i = 0; i < 4; i++)
2938 hw_breakpoint_insert(env, i);
2939 } else
2940 env->dr[reg] = t0;
2941 }
2942 #endif
2943
2944 void helper_lmsw(target_ulong t0)
2945 {
2946 /* only 4 lower bits of CR0 are modified. PE cannot be set to zero
2947 if already set to one. */
2948 t0 = (env->cr[0] & ~0xe) | (t0 & 0xf);
2949 helper_write_crN(0, t0);
2950 }
2951
2952 void helper_clts(void)
2953 {
2954 env->cr[0] &= ~CR0_TS_MASK;
2955 env->hflags &= ~HF_TS_MASK;
2956 }
2957
2958 void helper_invlpg(target_ulong addr)
2959 {
2960 helper_svm_check_intercept_param(SVM_EXIT_INVLPG, 0);
2961 tlb_flush_page(env, addr);
2962 }
2963
2964 void helper_rdtsc(void)
2965 {
2966 uint64_t val;
2967
2968 if ((env->cr[4] & CR4_TSD_MASK) && ((env->hflags & HF_CPL_MASK) != 0)) {
2969 raise_exception(EXCP0D_GPF);
2970 }
2971 helper_svm_check_intercept_param(SVM_EXIT_RDTSC, 0);
2972
2973 val = cpu_get_tsc(env) + env->tsc_offset;
2974 EAX = (uint32_t)(val);
2975 EDX = (uint32_t)(val >> 32);
2976 }
2977
2978 void helper_rdpmc(void)
2979 {
2980 if ((env->cr[4] & CR4_PCE_MASK) && ((env->hflags & HF_CPL_MASK) != 0)) {
2981 raise_exception(EXCP0D_GPF);
2982 }
2983 helper_svm_check_intercept_param(SVM_EXIT_RDPMC, 0);
2984
2985 /* currently unimplemented */
2986 raise_exception_err(EXCP06_ILLOP, 0);
2987 }
2988
2989 #if defined(CONFIG_USER_ONLY)
2990 void helper_wrmsr(void)
2991 {
2992 }
2993
2994 void helper_rdmsr(void)
2995 {
2996 }
2997 #else
2998 void helper_wrmsr(void)
2999 {
3000 uint64_t val;
3001
3002 helper_svm_check_intercept_param(SVM_EXIT_MSR, 1);
3003
3004 val = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
3005
3006 switch((uint32_t)ECX) {
3007 case MSR_IA32_SYSENTER_CS:
3008 env->sysenter_cs = val & 0xffff;
3009 break;
3010 case MSR_IA32_SYSENTER_ESP:
3011 env->sysenter_esp = val;
3012 break;
3013 case MSR_IA32_SYSENTER_EIP:
3014 env->sysenter_eip = val;
3015 break;
3016 case MSR_IA32_APICBASE:
3017 cpu_set_apic_base(env, val);
3018 break;
3019 case MSR_EFER:
3020 {
3021 uint64_t update_mask;
3022 update_mask = 0;
3023 if (env->cpuid_ext2_features & CPUID_EXT2_SYSCALL)
3024 update_mask |= MSR_EFER_SCE;
3025 if (env->cpuid_ext2_features & CPUID_EXT2_LM)
3026 update_mask |= MSR_EFER_LME;
3027 if (env->cpuid_ext2_features & CPUID_EXT2_FFXSR)
3028 update_mask |= MSR_EFER_FFXSR;
3029 if (env->cpuid_ext2_features & CPUID_EXT2_NX)
3030 update_mask |= MSR_EFER_NXE;
3031 if (env->cpuid_ext3_features & CPUID_EXT3_SVM)
3032 update_mask |= MSR_EFER_SVME;
3033 if (env->cpuid_ext2_features & CPUID_EXT2_FFXSR)
3034 update_mask |= MSR_EFER_FFXSR;
3035 cpu_load_efer(env, (env->efer & ~update_mask) |
3036 (val & update_mask));
3037 }
3038 break;
3039 case MSR_STAR:
3040 env->star = val;
3041 break;
3042 case MSR_PAT:
3043 env->pat = val;
3044 break;
3045 case MSR_VM_HSAVE_PA:
3046 env->vm_hsave = val;
3047 break;
3048 #ifdef TARGET_X86_64
3049 case MSR_LSTAR:
3050 env->lstar = val;
3051 break;
3052 case MSR_CSTAR:
3053 env->cstar = val;
3054 break;
3055 case MSR_FMASK:
3056 env->fmask = val;
3057 break;
3058 case MSR_FSBASE:
3059 env->segs[R_FS].base = val;
3060 break;
3061 case MSR_GSBASE:
3062 env->segs[R_GS].base = val;
3063 break;
3064 case MSR_KERNELGSBASE:
3065 env->kernelgsbase = val;
3066 break;
3067 #endif
3068 case MSR_MTRRphysBase(0):
3069 case MSR_MTRRphysBase(1):
3070 case MSR_MTRRphysBase(2):
3071 case MSR_MTRRphysBase(3):
3072 case MSR_MTRRphysBase(4):
3073 case MSR_MTRRphysBase(5):
3074 case MSR_MTRRphysBase(6):
3075 case MSR_MTRRphysBase(7):
3076 env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base = val;
3077 break;
3078 case MSR_MTRRphysMask(0):
3079 case MSR_MTRRphysMask(1):
3080 case MSR_MTRRphysMask(2):
3081 case MSR_MTRRphysMask(3):
3082 case MSR_MTRRphysMask(4):
3083 case MSR_MTRRphysMask(5):
3084 case MSR_MTRRphysMask(6):
3085 case MSR_MTRRphysMask(7):
3086 env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask = val;
3087 break;
3088 case MSR_MTRRfix64K_00000:
3089 env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix64K_00000] = val;
3090 break;
3091 case MSR_MTRRfix16K_80000:
3092 case MSR_MTRRfix16K_A0000:
3093 env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1] = val;
3094 break;
3095 case MSR_MTRRfix4K_C0000:
3096 case MSR_MTRRfix4K_C8000:
3097 case MSR_MTRRfix4K_D0000:
3098 case MSR_MTRRfix4K_D8000:
3099 case MSR_MTRRfix4K_E0000:
3100 case MSR_MTRRfix4K_E8000:
3101 case MSR_MTRRfix4K_F0000:
3102 case MSR_MTRRfix4K_F8000:
3103 env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3] = val;
3104 break;
3105 case MSR_MTRRdefType:
3106 env->mtrr_deftype = val;
3107 break;
3108 default:
3109 /* XXX: exception ? */
3110 break;
3111 }
3112 }
3113
3114 void helper_rdmsr(void)
3115 {
3116 uint64_t val;
3117
3118 helper_svm_check_intercept_param(SVM_EXIT_MSR, 0);
3119
3120 switch((uint32_t)ECX) {
3121 case MSR_IA32_SYSENTER_CS:
3122 val = env->sysenter_cs;
3123 break;
3124 case MSR_IA32_SYSENTER_ESP:
3125 val = env->sysenter_esp;
3126 break;
3127 case MSR_IA32_SYSENTER_EIP:
3128 val = env->sysenter_eip;
3129 break;
3130 case MSR_IA32_APICBASE:
3131 val = cpu_get_apic_base(env);
3132 break;
3133 case MSR_EFER:
3134 val = env->efer;
3135 break;
3136 case MSR_STAR:
3137 val = env->star;
3138 break;
3139 case MSR_PAT:
3140 val = env->pat;
3141 break;
3142 case MSR_VM_HSAVE_PA:
3143 val = env->vm_hsave;
3144 break;
3145 case MSR_IA32_PERF_STATUS:
3146 /* tsc_increment_by_tick */
3147 val = 1000ULL;
3148 /* CPU multiplier */
3149 val |= (((uint64_t)4ULL) << 40);
3150 break;
3151 #ifdef TARGET_X86_64
3152 case MSR_LSTAR:
3153 val = env->lstar;
3154 break;
3155 case MSR_CSTAR:
3156 val = env->cstar;
3157 break;
3158 case MSR_FMASK:
3159 val = env->fmask;
3160 break;
3161 case MSR_FSBASE:
3162 val = env->segs[R_FS].base;
3163 break;
3164 case MSR_GSBASE:
3165 val = env->segs[R_GS].base;
3166 break;
3167 case MSR_KERNELGSBASE:
3168 val = env->kernelgsbase;
3169 break;
3170 #endif
3171 #ifdef USE_KQEMU
3172 case MSR_QPI_COMMBASE:
3173 if (env->kqemu_enabled) {
3174 val = kqemu_comm_base;
3175 } else {
3176 val = 0;
3177 }
3178 break;
3179 #endif
3180 case MSR_MTRRphysBase(0):
3181 case MSR_MTRRphysBase(1):
3182 case MSR_MTRRphysBase(2):
3183 case MSR_MTRRphysBase(3):
3184 case MSR_MTRRphysBase(4):
3185 case MSR_MTRRphysBase(5):
3186 case MSR_MTRRphysBase(6):
3187 case MSR_MTRRphysBase(7):
3188 val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base;
3189 break;
3190 case MSR_MTRRphysMask(0):
3191 case MSR_MTRRphysMask(1):
3192 case MSR_MTRRphysMask(2):
3193 case MSR_MTRRphysMask(3):
3194 case MSR_MTRRphysMask(4):
3195 case MSR_MTRRphysMask(5):
3196 case MSR_MTRRphysMask(6):
3197 case MSR_MTRRphysMask(7):
3198 val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask;
3199 break;
3200 case MSR_MTRRfix64K_00000:
3201 val = env->mtrr_fixed[0];
3202 break;
3203 case MSR_MTRRfix16K_80000:
3204 case MSR_MTRRfix16K_A0000:
3205 val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1];
3206 break;
3207 case MSR_MTRRfix4K_C0000:
3208 case MSR_MTRRfix4K_C8000:
3209 case MSR_MTRRfix4K_D0000:
3210 case MSR_MTRRfix4K_D8000:
3211 case MSR_MTRRfix4K_E0000:
3212 case MSR_MTRRfix4K_E8000:
3213 case MSR_MTRRfix4K_F0000:
3214 case MSR_MTRRfix4K_F8000:
3215 val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3];
3216 break;
3217 case MSR_MTRRdefType:
3218 val = env->mtrr_deftype;
3219 break;
3220 case MSR_MTRRcap:
3221 if (env->cpuid_features & CPUID_MTRR)
3222 val = MSR_MTRRcap_VCNT | MSR_MTRRcap_FIXRANGE_SUPPORT | MSR_MTRRcap_WC_SUPPORTED;
3223 else
3224 /* XXX: exception ? */
3225 val = 0;
3226 break;
3227 default:
3228 /* XXX: exception ? */
3229 val = 0;
3230 break;
3231 }
3232 EAX = (uint32_t)(val);
3233 EDX = (uint32_t)(val >> 32);
3234 }
3235 #endif
3236
3237 target_ulong helper_lsl(target_ulong selector1)
3238 {
3239 unsigned int limit;
3240 uint32_t e1, e2, eflags, selector;
3241 int rpl, dpl, cpl, type;
3242
3243 selector = selector1 & 0xffff;
3244 eflags = helper_cc_compute_all(CC_OP);
3245 if (load_segment(&e1, &e2, selector) != 0)
3246 goto fail;
3247 rpl = selector & 3;
3248 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3249 cpl = env->hflags & HF_CPL_MASK;
3250 if (e2 & DESC_S_MASK) {
3251 if ((e2 & DESC_CS_MASK) && (e2 & DESC_C_MASK)) {
3252 /* conforming */
3253 } else {
3254 if (dpl < cpl || dpl < rpl)
3255 goto fail;
3256 }
3257 } else {
3258 type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
3259 switch(type) {
3260 case 1:
3261 case 2:
3262 case 3:
3263 case 9:
3264 case 11:
3265 break;
3266 default:
3267 goto fail;
3268 }
3269 if (dpl < cpl || dpl < rpl) {
3270 fail:
3271 CC_SRC = eflags & ~CC_Z;
3272 return 0;
3273 }
3274 }
3275 limit = get_seg_limit(e1, e2);
3276 CC_SRC = eflags | CC_Z;
3277 return limit;
3278 }
3279
3280 target_ulong helper_lar(target_ulong selector1)
3281 {
3282 uint32_t e1, e2, eflags, selector;
3283 int rpl, dpl, cpl, type;
3284
3285 selector = selector1 & 0xffff;
3286 eflags = helper_cc_compute_all(CC_OP);
3287 if ((selector & 0xfffc) == 0)
3288 goto fail;
3289 if (load_segment(&e1, &e2, selector) != 0)
3290 goto fail;
3291 rpl = selector & 3;
3292 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3293 cpl = env->hflags & HF_CPL_MASK;
3294 if (e2 & DESC_S_MASK) {
3295 if ((e2 & DESC_CS_MASK) && (e2 & DESC_C_MASK)) {
3296 /* conforming */
3297 } else {
3298 if (dpl < cpl || dpl < rpl)
3299 goto fail;
3300 }
3301 } else {
3302 type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
3303 switch(type) {
3304 case 1:
3305 case 2:
3306 case 3:
3307 case 4:
3308 case 5:
3309 case 9:
3310 case 11:
3311 case 12:
3312 break;
3313 default:
3314 goto fail;
3315 }
3316 if (dpl < cpl || dpl < rpl) {
3317 fail:
3318 CC_SRC = eflags & ~CC_Z;
3319 return 0;
3320 }
3321 }
3322 CC_SRC = eflags | CC_Z;
3323 return e2 & 0x00f0ff00;
3324 }
3325
3326 void helper_verr(target_ulong selector1)
3327 {
3328 uint32_t e1, e2, eflags, selector;
3329 int rpl, dpl, cpl;
3330
3331 selector = selector1 & 0xffff;
3332 eflags = helper_cc_compute_all(CC_OP);
3333 if ((selector & 0xfffc) == 0)
3334 goto fail;
3335 if (load_segment(&e1, &e2, selector) != 0)
3336 goto fail;
3337 if (!(e2 & DESC_S_MASK))
3338 goto fail;
3339 rpl = selector & 3;
3340 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3341 cpl = env->hflags & HF_CPL_MASK;
3342 if (e2 & DESC_CS_MASK) {
3343 if (!(e2 & DESC_R_MASK))
3344 goto fail;
3345 if (!(e2 & DESC_C_MASK)) {
3346 if (dpl < cpl || dpl < rpl)
3347 goto fail;
3348 }
3349 } else {
3350 if (dpl < cpl || dpl < rpl) {
3351 fail:
3352 CC_SRC = eflags & ~CC_Z;
3353 return;
3354 }
3355 }
3356 CC_SRC = eflags | CC_Z;
3357 }
3358
3359 void helper_verw(target_ulong selector1)
3360 {
3361 uint32_t e1, e2, eflags, selector;
3362 int rpl, dpl, cpl;
3363
3364 selector = selector1 & 0xffff;
3365 eflags = helper_cc_compute_all(CC_OP);
3366 if ((selector & 0xfffc) == 0)
3367 goto fail;
3368 if (load_segment(&e1, &e2, selector) != 0)
3369 goto fail;
3370 if (!(e2 & DESC_S_MASK))
3371 goto fail;
3372 rpl = selector & 3;
3373 dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3374 cpl = env->hflags & HF_CPL_MASK;
3375 if (e2 & DESC_CS_MASK) {
3376 goto fail;
3377 } else {
3378 if (dpl < cpl || dpl < rpl)
3379 goto fail;
3380 if (!(e2 & DESC_W_MASK)) {
3381 fail:
3382 CC_SRC = eflags & ~CC_Z;
3383 return;
3384 }
3385 }
3386 CC_SRC = eflags | CC_Z;
3387 }
3388
3389 /* x87 FPU helpers */
3390
3391 static void fpu_set_exception(int mask)
3392 {
3393 env->fpus |= mask;
3394 if (env->fpus & (~env->fpuc & FPUC_EM))
3395 env->fpus |= FPUS_SE | FPUS_B;
3396 }
3397
3398 static inline CPU86_LDouble helper_fdiv(CPU86_LDouble a, CPU86_LDouble b)
3399 {
3400 if (b == 0.0)
3401 fpu_set_exception(FPUS_ZE);
3402 return a / b;
3403 }
3404
3405 static void fpu_raise_exception(void)
3406 {
3407 if (env->cr[0] & CR0_NE_MASK) {
3408 raise_exception(EXCP10_COPR);
3409 }
3410 #if !defined(CONFIG_USER_ONLY)
3411 else {
3412 cpu_set_ferr(env);
3413 }
3414 #endif
3415 }
3416
3417 void helper_flds_FT0(uint32_t val)
3418 {
3419 union {
3420 float32 f;
3421 uint32_t i;
3422 } u;
3423 u.i = val;
3424 FT0 = float32_to_floatx(u.f, &env->fp_status);
3425 }
3426
3427 void helper_fldl_FT0(uint64_t val)
3428 {
3429 union {
3430 float64 f;
3431 uint64_t i;
3432 } u;
3433 u.i = val;
3434 FT0 = float64_to_floatx(u.f, &env->fp_status);
3435 }
3436
3437 void helper_fildl_FT0(int32_t val)
3438 {
3439 FT0 = int32_to_floatx(val, &env->fp_status);
3440 }
3441
3442 void helper_flds_ST0(uint32_t val)
3443 {
3444 int new_fpstt;
3445 union {
3446 float32 f;
3447 uint32_t i;
3448 } u;
3449 new_fpstt = (env->fpstt - 1) & 7;
3450 u.i = val;
3451 env->fpregs[new_fpstt].d = float32_to_floatx(u.f, &env->fp_status);
3452 env->fpstt = new_fpstt;
3453 env->fptags[new_fpstt] = 0; /* validate stack entry */
3454 }
3455
3456 void helper_fldl_ST0(uint64_t val)
3457 {
3458 int new_fpstt;
3459 union {
3460 float64 f;
3461 uint64_t i;
3462 } u;
3463 new_fpstt = (env->fpstt - 1) & 7;
3464 u.i = val;
3465 env->fpregs[new_fpstt].d = float64_to_floatx(u.f, &env->fp_status);
3466 env->fpstt = new_fpstt;
3467 env->fptags[new_fpstt] = 0; /* validate stack entry */
3468 }
3469
3470 void helper_fildl_ST0(int32_t val)
3471 {
3472 int new_fpstt;
3473 new_fpstt = (env->fpstt - 1) & 7;
3474 env->fpregs[new_fpstt].d = int32_to_floatx(val, &env->fp_status);
3475 env->fpstt = new_fpstt;
3476 env->fptags[new_fpstt] = 0; /* validate stack entry */
3477 }
3478
3479 void helper_fildll_ST0(int64_t val)
3480 {
3481 int new_fpstt;
3482 new_fpstt = (env->fpstt - 1) & 7;
3483 env->fpregs[new_fpstt].d = int64_to_floatx(val, &env->fp_status);
3484 env->fpstt = new_fpstt;
3485 env->fptags[new_fpstt] = 0; /* validate stack entry */
3486 }
3487
3488 uint32_t helper_fsts_ST0(void)
3489 {
3490 union {
3491 float32 f;
3492 uint32_t i;
3493 } u;
3494 u.f = floatx_to_float32(ST0, &env->fp_status);
3495 return u.i;
3496 }
3497
3498 uint64_t helper_fstl_ST0(void)
3499 {
3500 union {
3501 float64 f;
3502 uint64_t i;
3503 } u;
3504 u.f = floatx_to_float64(ST0, &env->fp_status);
3505 return u.i;
3506 }
3507
3508 int32_t helper_fist_ST0(void)
3509 {
3510 int32_t val;
3511 val = floatx_to_int32(ST0, &env->fp_status);
3512 if (val != (int16_t)val)
3513 val = -32768;
3514 return val;
3515 }
3516
3517 int32_t helper_fistl_ST0(void)
3518 {
3519 int32_t val;
3520 val = floatx_to_int32(ST0, &env->fp_status);
3521 return val;
3522 }
3523
3524 int64_t helper_fistll_ST0(void)
3525 {
3526 int64_t val;
3527 val = floatx_to_int64(ST0, &env->fp_status);
3528 return val;
3529 }
3530
3531 int32_t helper_fistt_ST0(void)
3532 {
3533 int32_t val;
3534 val = floatx_to_int32_round_to_zero(ST0, &env->fp_status);
3535 if (val != (int16_t)val)
3536 val = -32768;
3537 return val;
3538 }
3539
3540 int32_t helper_fisttl_ST0(void)
3541 {
3542 int32_t val;
3543 val = floatx_to_int32_round_to_zero(ST0, &env->fp_status);
3544 return val;
3545 }
3546
3547 int64_t helper_fisttll_ST0(void)
3548 {
3549 int64_t val;
3550 val = floatx_to_int64_round_to_zero(ST0, &env->fp_status);
3551 return val;
3552 }
3553
3554 void helper_fldt_ST0(target_ulong ptr)
3555 {
3556 int new_fpstt;
3557 new_fpstt = (env->fpstt - 1) & 7;
3558 env->fpregs[new_fpstt].d = helper_fldt(ptr);
3559 env->fpstt = new_fpstt;
3560 env->fptags[new_fpstt] = 0; /* validate stack entry */
3561 }
3562
3563 void helper_fstt_ST0(target_ulong ptr)
3564 {
3565 helper_fstt(ST0, ptr);
3566 }
3567
3568 void helper_fpush(void)
3569 {
3570 fpush();
3571 }
3572
3573 void helper_fpop(void)
3574 {
3575 fpop();
3576 }
3577
3578 void helper_fdecstp(void)
3579 {
3580 env->fpstt = (env->fpstt - 1) & 7;
3581 env->fpus &= (~0x4700);
3582 }
3583
3584 void helper_fincstp(void)
3585 {
3586 env->fpstt = (env->fpstt + 1) & 7;
3587 env->fpus &= (~0x4700);
3588 }
3589
3590 /* FPU move */
3591
3592 void helper_ffree_STN(int st_index)
3593 {
3594 env->fptags[(env->fpstt + st_index) & 7] = 1;
3595 }
3596
3597 void helper_fmov_ST0_FT0(void)
3598 {
3599 ST0 = FT0;
3600 }
3601
3602 void helper_fmov_FT0_STN(int st_index)
3603 {
3604 FT0 = ST(st_index);
3605 }
3606
3607 void helper_fmov_ST0_STN(int st_index)
3608 {
3609 ST0 = ST(st_index);
3610 }
3611
3612 void helper_fmov_STN_ST0(int st_index)
3613 {
3614 ST(st_index) = ST0;
3615 }
3616
3617 void helper_fxchg_ST0_STN(int st_index)
3618 {
3619 CPU86_LDouble tmp;
3620 tmp = ST(st_index);
3621 ST(st_index) = ST0;
3622 ST0 = tmp;
3623 }
3624
3625 /* FPU operations */
3626
3627 static const int fcom_ccval[4] = {0x0100, 0x4000, 0x0000, 0x4500};
3628
3629 void helper_fcom_ST0_FT0(void)
3630 {
3631 int ret;
3632
3633 ret = floatx_compare(ST0, FT0, &env->fp_status);
3634 env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret + 1];
3635 }
3636
3637 void helper_fucom_ST0_FT0(void)
3638 {
3639 int ret;
3640
3641 ret = floatx_compare_quiet(ST0, FT0, &env->fp_status);
3642 env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret+ 1];
3643 }
3644
3645 static const int fcomi_ccval[4] = {CC_C, CC_Z, 0, CC_Z | CC_P | CC_C};
3646
3647 void helper_fcomi_ST0_FT0(void)
3648 {
3649 int eflags;
3650 int ret;
3651
3652 ret = floatx_compare(ST0, FT0, &env->fp_status);
3653 eflags = helper_cc_compute_all(CC_OP);
3654 eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3655 CC_SRC = eflags;
3656 }
3657
3658 void helper_fucomi_ST0_FT0(void)
3659 {
3660 int eflags;
3661 int ret;
3662
3663 ret = floatx_compare_quiet(ST0, FT0, &env->fp_status);
3664 eflags = helper_cc_compute_all(CC_OP);
3665 eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3666 CC_SRC = eflags;
3667 }
3668
3669 void helper_fadd_ST0_FT0(void)
3670 {
3671 ST0 += FT0;
3672 }
3673
3674 void helper_fmul_ST0_FT0(void)
3675 {
3676 ST0 *= FT0;
3677 }
3678
3679 void helper_fsub_ST0_FT0(void)
3680 {
3681 ST0 -= FT0;
3682 }
3683
3684 void helper_fsubr_ST0_FT0(void)
3685 {
3686 ST0 = FT0 - ST0;
3687 }
3688
3689 void helper_fdiv_ST0_FT0(void)
3690 {
3691 ST0 = helper_fdiv(ST0, FT0);
3692 }
3693
3694 void helper_fdivr_ST0_FT0(void)
3695 {
3696 ST0 = helper_fdiv(FT0, ST0);
3697 }
3698
3699 /* fp operations between STN and ST0 */
3700
3701 void helper_fadd_STN_ST0(int st_index)
3702 {
3703 ST(st_index) += ST0;
3704 }
3705
3706 void helper_fmul_STN_ST0(int st_index)
3707 {
3708 ST(st_index) *= ST0;
3709 }
3710
3711 void helper_fsub_STN_ST0(int st_index)
3712 {
3713 ST(st_index) -= ST0;
3714 }
3715
3716 void helper_fsubr_STN_ST0(int st_index)
3717 {
3718 CPU86_LDouble *p;
3719 p = &ST(st_index);
3720 *p = ST0 - *p;
3721 }
3722
3723 void helper_fdiv_STN_ST0(int st_index)
3724 {
3725 CPU86_LDouble *p;
3726 p = &ST(st_index);
3727 *p = helper_fdiv(*p, ST0);
3728 }
3729
3730 void helper_fdivr_STN_ST0(int st_index)
3731 {
3732 CPU86_LDouble *p;
3733 p = &ST(st_index);
3734 *p = helper_fdiv(ST0, *p);
3735 }
3736
3737 /* misc FPU operations */
3738 void helper_fchs_ST0(void)
3739 {
3740 ST0 = floatx_chs(ST0);
3741 }
3742
3743 void helper_fabs_ST0(void)
3744 {
3745 ST0 = floatx_abs(ST0);
3746 }
3747
3748 void helper_fld1_ST0(void)
3749 {
3750 ST0 = f15rk[1];
3751 }
3752
3753 void helper_fldl2t_ST0(void)
3754 {
3755 ST0 = f15rk[6];
3756 }
3757
3758 void helper_fldl2e_ST0(void)
3759 {
3760 ST0 = f15rk[5];
3761 }
3762
3763 void helper_fldpi_ST0(void)
3764 {
3765 ST0 = f15rk[2];
3766 }
3767
3768 void helper_fldlg2_ST0(void)
3769 {
3770 ST0 = f15rk[3];
3771 }
3772
3773 void helper_fldln2_ST0(void)
3774 {
3775 ST0 = f15rk[4];
3776 }
3777
3778 void helper_fldz_ST0(void)
3779 {
3780 ST0 = f15rk[0];
3781 }
3782
3783 void helper_fldz_FT0(void)
3784 {
3785 FT0 = f15rk[0];
3786 }
3787
3788 uint32_t helper_fnstsw(void)
3789 {
3790 return (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
3791 }
3792
3793 uint32_t helper_fnstcw(void)
3794 {
3795 return env->fpuc;
3796 }
3797
3798 static void update_fp_status(void)
3799 {
3800 int rnd_type;
3801
3802 /* set rounding mode */
3803 switch(env->fpuc & RC_MASK) {
3804 default:
3805 case RC_NEAR:
3806 rnd_type = float_round_nearest_even;
3807 break;
3808 case RC_DOWN:
3809 rnd_type = float_round_down;
3810 break;
3811 case RC_UP:
3812 rnd_type = float_round_up;
3813 break;
3814 case RC_CHOP:
3815 rnd_type = float_round_to_zero;
3816 break;
3817 }
3818 set_float_rounding_mode(rnd_type, &env->fp_status);
3819 #ifdef FLOATX80
3820 switch((env->fpuc >> 8) & 3) {
3821 case 0:
3822 rnd_type = 32;
3823 break;
3824 case 2:
3825 rnd_type = 64;
3826 break;
3827 case 3:
3828 default:
3829 rnd_type = 80;
3830 break;
3831 }
3832 set_floatx80_rounding_precision(rnd_type, &env->fp_status);
3833 #endif
3834 }
3835
3836 void helper_fldcw(uint32_t val)
3837 {
3838 env->fpuc = val;
3839 update_fp_status();
3840 }
3841
3842 void helper_fclex(void)
3843 {
3844 env->fpus &= 0x7f00;
3845 }
3846
3847 void helper_fwait(void)
3848 {
3849 if (env->fpus & FPUS_SE)
3850 fpu_raise_exception();
3851 }
3852
3853 void helper_fninit(void)
3854 {
3855 env->fpus = 0;
3856 env->fpstt = 0;
3857 env->fpuc = 0x37f;
3858 env->fptags[0] = 1;
3859 env->fptags[1] = 1;
3860 env->fptags[2] = 1;
3861 env->fptags[3] = 1;
3862 env->fptags[4] = 1;
3863 env->fptags[5] = 1;
3864 env->fptags[6] = 1;
3865 env->fptags[7] = 1;
3866 }
3867
3868 /* BCD ops */
3869
3870 void helper_fbld_ST0(target_ulong ptr)
3871 {
3872 CPU86_LDouble tmp;
3873 uint64_t val;
3874 unsigned int v;
3875 int i;
3876
3877 val = 0;
3878 for(i = 8; i >= 0; i--) {
3879 v = ldub(ptr + i);
3880 val = (val * 100) + ((v >> 4) * 10) + (v & 0xf);
3881 }
3882 tmp = val;
3883 if (ldub(ptr + 9) & 0x80)
3884 tmp = -tmp;
3885 fpush();
3886 ST0 = tmp;
3887 }
3888
3889 void helper_fbst_ST0(target_ulong ptr)
3890 {
3891 int v;
3892 target_ulong mem_ref, mem_end;
3893 int64_t val;
3894
3895 val = floatx_to_int64(ST0, &env->fp_status);
3896 mem_ref = ptr;
3897 mem_end = mem_ref + 9;
3898 if (val < 0) {
3899 stb(mem_end, 0x80);
3900 val = -val;
3901 } else {
3902 stb(mem_end, 0x00);
3903 }
3904 while (mem_ref < mem_end) {
3905 if (val == 0)
3906 break;
3907 v = val % 100;
3908 val = val / 100;
3909 v = ((v / 10) << 4) | (v % 10);
3910 stb(mem_ref++, v);
3911 }
3912 while (mem_ref < mem_end) {
3913 stb(mem_ref++, 0);
3914 }
3915 }
3916
3917 void helper_f2xm1(void)
3918 {
3919 ST0 = pow(2.0,ST0) - 1.0;
3920 }
3921
3922 void helper_fyl2x(void)
3923 {
3924 CPU86_LDouble fptemp;
3925
3926 fptemp = ST0;
3927 if (fptemp>0.0){
3928 fptemp = log(fptemp)/log(2.0); /* log2(ST) */
3929 ST1 *= fptemp;
3930 fpop();
3931 } else {
3932 env->fpus &= (~0x4700);
3933 env->fpus |= 0x400;
3934 }
3935 }
3936
3937 void helper_fptan(void)
3938 {
3939 CPU86_LDouble fptemp;
3940
3941 fptemp = ST0;
3942 if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
3943 env->fpus |= 0x400;
3944 } else {
3945 ST0 = tan(fptemp);
3946 fpush();
3947 ST0 = 1.0;
3948 env->fpus &= (~0x400); /* C2 <-- 0 */
3949 /* the above code is for |arg| < 2**52 only */
3950 }
3951 }
3952
3953 void helper_fpatan(void)
3954 {
3955 CPU86_LDouble fptemp, fpsrcop;
3956
3957 fpsrcop = ST1;
3958 fptemp = ST0;
3959 ST1 = atan2(fpsrcop,fptemp);
3960 fpop();
3961 }
3962
3963 void helper_fxtract(void)
3964 {
3965 CPU86_LDoubleU temp;
3966 unsigned int expdif;
3967
3968 temp.d = ST0;
3969 expdif = EXPD(temp) - EXPBIAS;
3970 /*DP exponent bias*/
3971 ST0 = expdif;
3972 fpush();
3973 BIASEXPONENT(temp);
3974 ST0 = temp.d;
3975 }
3976
3977 void helper_fprem1(void)
3978 {
3979 CPU86_LDouble dblq, fpsrcop, fptemp;
3980 CPU86_LDoubleU fpsrcop1, fptemp1;
3981 int expdif;
3982 signed long long int q;
3983
3984 if (isinf(ST0) || isnan(ST0) || isnan(ST1) || (ST1 == 0.0)) {
3985 ST0 = 0.0 / 0.0; /* NaN */
3986 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
3987 return;
3988 }
3989
3990 fpsrcop = ST0;
3991 fptemp = ST1;
3992 fpsrcop1.d = fpsrcop;
3993 fptemp1.d = fptemp;
3994 expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
3995
3996 if (expdif < 0) {
3997 /* optimisation? taken from the AMD docs */
3998 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
3999 /* ST0 is unchanged */
4000 return;
4001 }
4002
4003 if (expdif < 53) {
4004 dblq = fpsrcop / fptemp;
4005 /* round dblq towards nearest integer */
4006 dblq = rint(dblq);
4007 ST0 = fpsrcop - fptemp * dblq;
4008
4009 /* convert dblq to q by truncating towards zero */
4010 if (dblq < 0.0)
4011 q = (signed long long int)(-dblq);
4012 else
4013 q = (signed long long int)dblq;
4014
4015 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4016 /* (C0,C3,C1) <-- (q2,q1,q0) */
4017 env->fpus |= (q & 0x4) << (8 - 2); /* (C0) <-- q2 */
4018 env->fpus |= (q & 0x2) << (14 - 1); /* (C3) <-- q1 */
4019 env->fpus |= (q & 0x1) << (9 - 0); /* (C1) <-- q0 */
4020 } else {
4021 env->fpus |= 0x400; /* C2 <-- 1 */
4022 fptemp = pow(2.0, expdif - 50);
4023 fpsrcop = (ST0 / ST1) / fptemp;
4024 /* fpsrcop = integer obtained by chopping */
4025 fpsrcop = (fpsrcop < 0.0) ?
4026 -(floor(fabs(fpsrcop))) : floor(fpsrcop);
4027 ST0 -= (ST1 * fpsrcop * fptemp);
4028 }
4029 }
4030
4031 void helper_fprem(void)
4032 {
4033 CPU86_LDouble dblq, fpsrcop, fptemp;
4034 CPU86_LDoubleU fpsrcop1, fptemp1;
4035 int expdif;
4036 signed long long int q;
4037
4038 if (isinf(ST0) || isnan(ST0) || isnan(ST1) || (ST1 == 0.0)) {
4039 ST0 = 0.0 / 0.0; /* NaN */
4040 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4041 return;
4042 }
4043
4044 fpsrcop = (CPU86_LDouble)ST0;
4045 fptemp = (CPU86_LDouble)ST1;
4046 fpsrcop1.d = fpsrcop;
4047 fptemp1.d = fptemp;
4048 expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
4049
4050 if (expdif < 0) {
4051 /* optimisation? taken from the AMD docs */
4052 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4053 /* ST0 is unchanged */
4054 return;
4055 }
4056
4057 if ( expdif < 53 ) {
4058 dblq = fpsrcop/*ST0*/ / fptemp/*ST1*/;
4059 /* round dblq towards zero */
4060 dblq = (dblq < 0.0) ? ceil(dblq) : floor(dblq);
4061 ST0 = fpsrcop/*ST0*/ - fptemp * dblq;
4062
4063 /* convert dblq to q by truncating towards zero */
4064 if (dblq < 0.0)
4065 q = (signed long long int)(-dblq);
4066 else
4067 q = (signed long long int)dblq;
4068
4069 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4070 /* (C0,C3,C1) <-- (q2,q1,q0) */
4071 env->fpus |= (q & 0x4) << (8 - 2); /* (C0) <-- q2 */
4072 env->fpus |= (q & 0x2) << (14 - 1); /* (C3) <-- q1 */
4073 env->fpus |= (q & 0x1) << (9 - 0); /* (C1) <-- q0 */
4074 } else {
4075 int N = 32 + (expdif % 32); /* as per AMD docs */
4076 env->fpus |= 0x400; /* C2 <-- 1 */
4077 fptemp = pow(2.0, (double)(expdif - N));
4078 fpsrcop = (ST0 / ST1) / fptemp;
4079 /* fpsrcop = integer obtained by chopping */
4080 fpsrcop = (fpsrcop < 0.0) ?
4081 -(floor(fabs(fpsrcop))) : floor(fpsrcop);
4082 ST0 -= (ST1 * fpsrcop * fptemp);
4083 }
4084 }
4085
4086 void helper_fyl2xp1(void)
4087 {
4088 CPU86_LDouble fptemp;
4089
4090 fptemp = ST0;
4091 if ((fptemp+1.0)>0.0) {
4092 fptemp = log(fptemp+1.0) / log(2.0); /* log2(ST+1.0) */
4093 ST1 *= fptemp;
4094 fpop();
4095 } else {
4096 env->fpus &= (~0x4700);
4097 env->fpus |= 0x400;
4098 }
4099 }
4100
4101 void helper_fsqrt(void)
4102 {
4103 CPU86_LDouble fptemp;
4104
4105 fptemp = ST0;
4106 if (fptemp<0.0) {
4107 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4108 env->fpus |= 0x400;
4109 }
4110 ST0 = sqrt(fptemp);
4111 }
4112
4113 void helper_fsincos(void)
4114 {
4115 CPU86_LDouble fptemp;
4116
4117 fptemp = ST0;
4118 if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4119 env->fpus |= 0x400;
4120 } else {
4121 ST0 = sin(fptemp);
4122 fpush();
4123 ST0 = cos(fptemp);
4124 env->fpus &= (~0x400); /* C2 <-- 0 */
4125 /* the above code is for |arg| < 2**63 only */
4126 }
4127 }
4128
4129 void helper_frndint(void)
4130 {
4131 ST0 = floatx_round_to_int(ST0, &env->fp_status);
4132 }
4133
4134 void helper_fscale(void)
4135 {
4136 ST0 = ldexp (ST0, (int)(ST1));
4137 }
4138
4139 void helper_fsin(void)
4140 {
4141 CPU86_LDouble fptemp;
4142
4143 fptemp = ST0;
4144 if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4145 env->fpus |= 0x400;
4146 } else {
4147 ST0 = sin(fptemp);
4148 env->fpus &= (~0x400); /* C2 <-- 0 */
4149 /* the above code is for |arg| < 2**53 only */
4150 }
4151 }
4152
4153 void helper_fcos(void)
4154 {
4155 CPU86_LDouble fptemp;
4156
4157 fptemp = ST0;
4158 if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4159 env->fpus |= 0x400;
4160 } else {
4161 ST0 = cos(fptemp);
4162 env->fpus &= (~0x400); /* C2 <-- 0 */
4163 /* the above code is for |arg5 < 2**63 only */
4164 }
4165 }
4166
4167 void helper_fxam_ST0(void)
4168 {
4169 CPU86_LDoubleU temp;
4170 int expdif;
4171
4172 temp.d = ST0;
4173
4174 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4175 if (SIGND(temp))
4176 env->fpus |= 0x200; /* C1 <-- 1 */
4177
4178 /* XXX: test fptags too */
4179 expdif = EXPD(temp);
4180 if (expdif == MAXEXPD) {
4181 #ifdef USE_X86LDOUBLE
4182 if (MANTD(temp) == 0x8000000000000000ULL)
4183 #else
4184 if (MANTD(temp) == 0)
4185 #endif
4186 env->fpus |= 0x500 /*Infinity*/;
4187 else
4188 env->fpus |= 0x100 /*NaN*/;
4189 } else if (expdif == 0) {
4190 if (MANTD(temp) == 0)
4191 env->fpus |= 0x4000 /*Zero*/;
4192 else
4193 env->fpus |= 0x4400 /*Denormal*/;
4194 } else {
4195 env->fpus |= 0x400;
4196 }
4197 }
4198
4199 void helper_fstenv(target_ulong ptr, int data32)
4200 {
4201 int fpus, fptag, exp, i;
4202 uint64_t mant;
4203 CPU86_LDoubleU tmp;
4204
4205 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
4206 fptag = 0;
4207 for (i=7; i>=0; i--) {
4208 fptag <<= 2;
4209 if (env->fptags[i]) {
4210 fptag |= 3;
4211 } else {
4212 tmp.d = env->fpregs[i].d;
4213 exp = EXPD(tmp);
4214 mant = MANTD(tmp);
4215 if (exp == 0 && mant == 0) {
4216 /* zero */
4217 fptag |= 1;
4218 } else if (exp == 0 || exp == MAXEXPD
4219 #ifdef USE_X86LDOUBLE
4220 || (mant & (1LL << 63)) == 0
4221 #endif
4222 ) {
4223 /* NaNs, infinity, denormal */
4224 fptag |= 2;
4225 }
4226 }
4227 }
4228 if (data32) {
4229 /* 32 bit */
4230 stl(ptr, env->fpuc);
4231 stl(ptr + 4, fpus);
4232 stl(ptr + 8, fptag);
4233 stl(ptr + 12, 0); /* fpip */
4234 stl(ptr + 16, 0); /* fpcs */
4235 stl(ptr + 20, 0); /* fpoo */
4236 stl(ptr + 24, 0); /* fpos */
4237 } else {
4238 /* 16 bit */
4239 stw(ptr, env->fpuc);
4240 stw(ptr + 2, fpus);
4241 stw(ptr + 4, fptag);
4242 stw(ptr + 6, 0);
4243 stw(ptr + 8, 0);
4244 stw(ptr + 10, 0);
4245 stw(ptr + 12, 0);
4246 }
4247 }
4248
4249 void helper_fldenv(target_ulong ptr, int data32)
4250 {
4251 int i, fpus, fptag;
4252
4253 if (data32) {
4254 env->fpuc = lduw(ptr);
4255 fpus = lduw(ptr + 4);
4256 fptag = lduw(ptr + 8);
4257 }
4258 else {
4259 env->fpuc = lduw(ptr);
4260 fpus = lduw(ptr + 2);
4261 fptag = lduw(ptr + 4);
4262 }
4263 env->fpstt = (fpus >> 11) & 7;
4264 env->fpus = fpus & ~0x3800;
4265 for(i = 0;i < 8; i++) {
4266 env->fptags[i] = ((fptag & 3) == 3);
4267 fptag >>= 2;
4268 }
4269 }
4270
4271 void helper_fsave(target_ulong ptr, int data32)
4272 {
4273 CPU86_LDouble tmp;
4274 int i;
4275
4276 helper_fstenv(ptr, data32);
4277
4278 ptr += (14 << data32);
4279 for(i = 0;i < 8; i++) {
4280 tmp = ST(i);
4281 helper_fstt(tmp, ptr);
4282 ptr += 10;
4283 }
4284
4285 /* fninit */
4286 env->fpus = 0;
4287 env->fpstt = 0;
4288 env->fpuc = 0x37f;
4289 env->fptags[0] = 1;
4290 env->fptags[1] = 1;
4291 env->fptags[2] = 1;
4292 env->fptags[3] = 1;
4293 env->fptags[4] = 1;
4294 env->fptags[5] = 1;
4295 env->fptags[6] = 1;
4296 env->fptags[7] = 1;
4297 }
4298
4299 void helper_frstor(target_ulong ptr, int data32)
4300 {
4301 CPU86_LDouble tmp;
4302 int i;
4303
4304 helper_fldenv(ptr, data32);
4305 ptr += (14 << data32);
4306
4307 for(i = 0;i < 8; i++) {
4308 tmp = helper_fldt(ptr);
4309 ST(i) = tmp;
4310 ptr += 10;
4311 }
4312 }
4313
4314 void helper_fxsave(target_ulong ptr, int data64)
4315 {
4316 int fpus, fptag, i, nb_xmm_regs;
4317 CPU86_LDouble tmp;
4318 target_ulong addr;
4319
4320 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
4321 fptag = 0;
4322 for(i = 0; i < 8; i++) {
4323 fptag |= (env->fptags[i] << i);
4324 }
4325 stw(ptr, env->fpuc);
4326 stw(ptr + 2, fpus);
4327 stw(ptr + 4, fptag ^ 0xff);
4328 #ifdef TARGET_X86_64
4329 if (data64) {
4330 stq(ptr + 0x08, 0); /* rip */
4331 stq(ptr + 0x10, 0); /* rdp */
4332 } else
4333 #endif
4334 {
4335 stl(ptr + 0x08, 0); /* eip */
4336 stl(ptr + 0x0c, 0); /* sel */
4337 stl(ptr + 0x10, 0); /* dp */
4338 stl(ptr + 0x14, 0); /* sel */
4339 }
4340
4341 addr = ptr + 0x20;
4342 for(i = 0;i < 8; i++) {
4343 tmp = ST(i);
4344 helper_fstt(tmp, addr);
4345 addr += 16;
4346 }
4347
4348 if (env->cr[4] & CR4_OSFXSR_MASK) {
4349 /* XXX: finish it */
4350 stl(ptr + 0x18, env->mxcsr); /* mxcsr */
4351 stl(ptr + 0x1c, 0x0000ffff); /* mxcsr_mask */
4352 if (env->hflags & HF_CS64_MASK)
4353 nb_xmm_regs = 16;
4354 else
4355 nb_xmm_regs = 8;
4356 addr = ptr + 0xa0;
4357 /* Fast FXSAVE leaves out the XMM registers */
4358 if (!(env->efer & MSR_EFER_FFXSR)
4359 || (env->hflags & HF_CPL_MASK)
4360 || !(env->hflags & HF_LMA_MASK)) {
4361 for(i = 0; i < nb_xmm_regs; i++) {
4362 stq(addr, env->xmm_regs[i].XMM_Q(0));
4363 stq(addr + 8, env->xmm_regs[i].XMM_Q(1));
4364 addr += 16;
4365 }
4366 }
4367 }
4368 }
4369
4370 void helper_fxrstor(target_ulong ptr, int data64)
4371 {
4372 int i, fpus, fptag, nb_xmm_regs;
4373 CPU86_LDouble tmp;
4374 target_ulong addr;
4375
4376 env->fpuc = lduw(ptr);
4377 fpus = lduw(ptr + 2);
4378 fptag = lduw(ptr + 4);
4379 env->fpstt = (fpus >> 11) & 7;
4380 env->fpus = fpus & ~0x3800;
4381 fptag ^= 0xff;
4382 for(i = 0;i < 8; i++) {
4383 env->fptags[i] = ((fptag >> i) & 1);
4384 }
4385
4386 addr = ptr + 0x20;
4387 for(i = 0;i < 8; i++) {
4388 tmp = helper_fldt(addr);
4389 ST(i) = tmp;
4390 addr += 16;
4391 }
4392
4393 if (env->cr[4] & CR4_OSFXSR_MASK) {
4394 /* XXX: finish it */
4395 env->mxcsr = ldl(ptr + 0x18);
4396 //ldl(ptr + 0x1c);
4397 if (env->hflags & HF_CS64_MASK)
4398 nb_xmm_regs = 16;
4399 else
4400 nb_xmm_regs = 8;
4401 addr = ptr + 0xa0;
4402 /* Fast FXRESTORE leaves out the XMM registers */
4403 if (!(env->efer & MSR_EFER_FFXSR)
4404 || (env->hflags & HF_CPL_MASK)
4405 || !(env->hflags & HF_LMA_MASK)) {
4406 for(i = 0; i < nb_xmm_regs; i++) {
4407 env->xmm_regs[i].XMM_Q(0) = ldq(addr);
4408 env->xmm_regs[i].XMM_Q(1) = ldq(addr + 8);
4409 addr += 16;
4410 }
4411 }
4412 }
4413 }
4414
4415 #ifndef USE_X86LDOUBLE
4416
4417 void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, CPU86_LDouble f)
4418 {
4419 CPU86_LDoubleU temp;
4420 int e;
4421
4422 temp.d = f;
4423 /* mantissa */
4424 *pmant = (MANTD(temp) << 11) | (1LL << 63);
4425 /* exponent + sign */
4426 e = EXPD(temp) - EXPBIAS + 16383;
4427 e |= SIGND(temp) >> 16;
4428 *pexp = e;
4429 }
4430
4431 CPU86_LDouble cpu_set_fp80(uint64_t mant, uint16_t upper)
4432 {
4433 CPU86_LDoubleU temp;
4434 int e;
4435 uint64_t ll;
4436
4437 /* XXX: handle overflow ? */
4438 e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */
4439 e |= (upper >> 4) & 0x800; /* sign */
4440 ll = (mant >> 11) & ((1LL << 52) - 1);
4441 #ifdef __arm__
4442 temp.l.upper = (e << 20) | (ll >> 32);
4443 temp.l.lower = ll;
4444 #else
4445 temp.ll = ll | ((uint64_t)e << 52);
4446 #endif
4447 return temp.d;
4448 }
4449
4450 #else
4451
4452 void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, CPU86_LDouble f)
4453 {
4454 CPU86_LDoubleU temp;
4455
4456 temp.d = f;
4457 *pmant = temp.l.lower;
4458 *pexp = temp.l.upper;
4459 }
4460
4461 CPU86_LDouble cpu_set_fp80(uint64_t mant, uint16_t upper)
4462 {
4463 CPU86_LDoubleU temp;
4464
4465 temp.l.upper = upper;
4466 temp.l.lower = mant;
4467 return temp.d;
4468 }
4469 #endif
4470
4471 #ifdef TARGET_X86_64
4472
4473 //#define DEBUG_MULDIV
4474
4475 static void add128(uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)
4476 {
4477 *plow += a;
4478 /* carry test */
4479 if (*plow < a)
4480 (*phigh)++;
4481 *phigh += b;
4482 }
4483
4484 static void neg128(uint64_t *plow, uint64_t *phigh)
4485 {
4486 *plow = ~ *plow;
4487 *phigh = ~ *phigh;
4488 add128(plow, phigh, 1, 0);
4489 }
4490
4491 /* return TRUE if overflow */
4492 static int div64(uint64_t *plow, uint64_t *phigh, uint64_t b)
4493 {
4494 uint64_t q, r, a1, a0;
4495 int i, qb, ab;
4496
4497 a0 = *plow;
4498 a1 = *phigh;
4499 if (a1 == 0) {
4500 q = a0 / b;
4501 r = a0 % b;
4502 *plow = q;
4503 *phigh = r;
4504 } else {
4505 if (a1 >= b)
4506 return 1;
4507 /* XXX: use a better algorithm */
4508 for(i = 0; i < 64; i++) {
4509 ab = a1 >> 63;
4510 a1 = (a1 << 1) | (a0 >> 63);
4511 if (ab || a1 >= b) {
4512 a1 -= b;
4513 qb = 1;
4514 } else {
4515 qb = 0;
4516 }
4517 a0 = (a0 << 1) | qb;
4518 }
4519 #if defined(DEBUG_MULDIV)
4520 printf("div: 0x%016" PRIx64 "%016" PRIx64 " / 0x%016" PRIx64 ": q=0x%016" PRIx64 " r=0x%016" PRIx64 "\n",
4521 *phigh, *plow, b, a0, a1);
4522 #endif
4523 *plow = a0;
4524 *phigh = a1;
4525 }
4526 return 0;
4527 }
4528
4529 /* return TRUE if overflow */
4530 static int idiv64(uint64_t *plow, uint64_t *phigh, int64_t b)
4531 {
4532 int sa, sb;
4533 sa = ((int64_t)*phigh < 0);
4534 if (sa)
4535 neg128(plow, phigh);
4536 sb = (b < 0);
4537 if (sb)
4538 b = -b;
4539 if (div64(plow, phigh, b) != 0)
4540 return 1;
4541 if (sa ^ sb) {
4542 if (*plow > (1ULL << 63))
4543 return 1;
4544 *plow = - *plow;
4545 } else {
4546 if (*plow >= (1ULL << 63))
4547 return 1;
4548 }
4549 if (sa)
4550 *phigh = - *phigh;
4551 return 0;
4552 }
4553
4554 void helper_mulq_EAX_T0(target_ulong t0)
4555 {
4556 uint64_t r0, r1;
4557
4558 mulu64(&r0, &r1, EAX, t0);
4559 EAX = r0;
4560 EDX = r1;
4561 CC_DST = r0;
4562 CC_SRC = r1;
4563 }
4564
4565 void helper_imulq_EAX_T0(target_ulong t0)
4566 {
4567 uint64_t r0, r1;
4568
4569 muls64(&r0, &r1, EAX, t0);
4570 EAX = r0;
4571 EDX = r1;
4572 CC_DST = r0;
4573 CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
4574 }
4575
4576 target_ulong helper_imulq_T0_T1(target_ulong t0, target_ulong t1)
4577 {
4578 uint64_t r0, r1;
4579
4580 muls64(&r0, &r1, t0, t1);
4581 CC_DST = r0;
4582 CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
4583 return r0;
4584 }
4585
4586 void helper_divq_EAX(target_ulong t0)
4587 {
4588 uint64_t r0, r1;
4589 if (t0 == 0) {
4590 raise_exception(EXCP00_DIVZ);
4591 }
4592 r0 = EAX;
4593 r1 = EDX;
4594 if (div64(&r0, &r1, t0))
4595 raise_exception(EXCP00_DIVZ);
4596 EAX = r0;
4597 EDX = r1;
4598 }
4599
4600 void helper_idivq_EAX(target_ulong t0)
4601 {
4602 uint64_t r0, r1;
4603 if (t0 == 0) {
4604 raise_exception(EXCP00_DIVZ);
4605 }
4606 r0 = EAX;
4607 r1 = EDX;
4608 if (idiv64(&r0, &r1, t0))
4609 raise_exception(EXCP00_DIVZ);
4610 EAX = r0;
4611 EDX = r1;
4612 }
4613 #endif
4614
4615 static void do_hlt(void)
4616 {
4617 env->hflags &= ~HF_INHIBIT_IRQ_MASK; /* needed if sti is just before */
4618 env->halted = 1;
4619 env->exception_index = EXCP_HLT;
4620 cpu_loop_exit();
4621 }
4622
4623 void helper_hlt(int next_eip_addend)
4624 {
4625 helper_svm_check_intercept_param(SVM_EXIT_HLT, 0);
4626 EIP += next_eip_addend;
4627
4628 do_hlt();
4629 }
4630
4631 void helper_monitor(target_ulong ptr)
4632 {
4633 if ((uint32_t)ECX != 0)
4634 raise_exception(EXCP0D_GPF);
4635 /* XXX: store address ? */
4636 helper_svm_check_intercept_param(SVM_EXIT_MONITOR, 0);
4637 }
4638
4639 void helper_mwait(int next_eip_addend)
4640 {
4641 if ((uint32_t)ECX != 0)
4642 raise_exception(EXCP0D_GPF);
4643 helper_svm_check_intercept_param(SVM_EXIT_MWAIT, 0);
4644 EIP += next_eip_addend;
4645
4646 /* XXX: not complete but not completely erroneous */
4647 if (env->cpu_index != 0 || env->next_cpu != NULL) {
4648 /* more than one CPU: do not sleep because another CPU may
4649 wake this one */
4650 } else {
4651 do_hlt();
4652 }
4653 }
4654
4655 void helper_debug(void)
4656 {
4657 env->exception_index = EXCP_DEBUG;
4658 cpu_loop_exit();
4659 }
4660
4661 void helper_raise_interrupt(int intno, int next_eip_addend)
4662 {
4663 raise_interrupt(intno, 1, 0, next_eip_addend);
4664 }
4665
4666 void helper_raise_exception(int exception_index)
4667 {
4668 raise_exception(exception_index);
4669 }
4670
4671 void helper_cli(void)
4672 {
4673 env->eflags &= ~IF_MASK;
4674 }
4675
4676 void helper_sti(void)
4677 {
4678 env->eflags |= IF_MASK;
4679 }
4680
4681 #if 0
4682 /* vm86plus instructions */
4683 void helper_cli_vm(void)
4684 {
4685 env->eflags &= ~VIF_MASK;
4686 }
4687
4688 void helper_sti_vm(void)
4689 {
4690 env->eflags |= VIF_MASK;
4691 if (env->eflags & VIP_MASK) {
4692 raise_exception(EXCP0D_GPF);
4693 }
4694 }
4695 #endif
4696
4697 void helper_set_inhibit_irq(void)
4698 {
4699 env->hflags |= HF_INHIBIT_IRQ_MASK;
4700 }
4701
4702 void helper_reset_inhibit_irq(void)
4703 {
4704 env->hflags &= ~HF_INHIBIT_IRQ_MASK;
4705 }
4706
4707 void helper_boundw(target_ulong a0, int v)
4708 {
4709 int low, high;
4710 low = ldsw(a0);
4711 high = ldsw(a0 + 2);
4712 v = (int16_t)v;
4713 if (v < low || v > high) {
4714 raise_exception(EXCP05_BOUND);
4715 }
4716 }
4717
4718 void helper_boundl(target_ulong a0, int v)
4719 {
4720 int low, high;
4721 low = ldl(a0);
4722 high = ldl(a0 + 4);
4723 if (v < low || v > high) {
4724 raise_exception(EXCP05_BOUND);
4725 }
4726 }
4727
4728 static float approx_rsqrt(float a)
4729 {
4730 return 1.0 / sqrt(a);
4731 }
4732
4733 static float approx_rcp(float a)
4734 {
4735 return 1.0 / a;
4736 }
4737
4738 #if !defined(CONFIG_USER_ONLY)
4739
4740 #define MMUSUFFIX _mmu
4741
4742 #define SHIFT 0
4743 #include "softmmu_template.h"
4744
4745 #define SHIFT 1
4746 #include "softmmu_template.h"
4747
4748 #define SHIFT 2
4749 #include "softmmu_template.h"
4750
4751 #define SHIFT 3
4752 #include "softmmu_template.h"
4753
4754 #endif
4755
4756 #if !defined(CONFIG_USER_ONLY)
4757 /* try to fill the TLB and return an exception if error. If retaddr is
4758 NULL, it means that the function was called in C code (i.e. not
4759 from generated code or from helper.c) */
4760 /* XXX: fix it to restore all registers */
4761 void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
4762 {
4763 TranslationBlock *tb;
4764 int ret;
4765 unsigned long pc;
4766 CPUX86State *saved_env;
4767
4768 /* XXX: hack to restore env in all cases, even if not called from
4769 generated code */
4770 saved_env = env;
4771 env = cpu_single_env;
4772
4773 ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
4774 if (ret) {
4775 if (retaddr) {
4776 /* now we have a real cpu fault */
4777 pc = (unsigned long)retaddr;
4778 tb = tb_find_pc(pc);
4779 if (tb) {
4780 /* the PC is inside the translated code. It means that we have
4781 a virtual CPU fault */
4782 cpu_restore_state(tb, env, pc, NULL);
4783 }
4784 }
4785 raise_exception_err(env->exception_index, env->error_code);
4786 }
4787 env = saved_env;
4788 }
4789 #endif
4790
4791 /* Secure Virtual Machine helpers */
4792
4793 #if defined(CONFIG_USER_ONLY)
4794
4795 void helper_vmrun(int aflag, int next_eip_addend)
4796 {
4797 }
4798 void helper_vmmcall(void)
4799 {
4800 }
4801 void helper_vmload(int aflag)
4802 {
4803 }
4804 void helper_vmsave(int aflag)
4805 {
4806 }
4807 void helper_stgi(void)
4808 {
4809 }
4810 void helper_clgi(void)
4811 {
4812 }
4813 void helper_skinit(void)
4814 {
4815 }
4816 void helper_invlpga(int aflag)
4817 {
4818 }
4819 void helper_vmexit(uint32_t exit_code, uint64_t exit_info_1)
4820 {
4821 }
4822 void helper_svm_check_intercept_param(uint32_t type, uint64_t param)
4823 {
4824 }
4825
4826 void helper_svm_check_io(uint32_t port, uint32_t param,
4827 uint32_t next_eip_addend)
4828 {
4829 }
4830 #else
4831
4832 static inline void svm_save_seg(target_phys_addr_t addr,
4833 const SegmentCache *sc)
4834 {
4835 stw_phys(addr + offsetof(struct vmcb_seg, selector),
4836 sc->selector);
4837 stq_phys(addr + offsetof(struct vmcb_seg, base),
4838 sc->base);
4839 stl_phys(addr + offsetof(struct vmcb_seg, limit),
4840 sc->limit);
4841 stw_phys(addr + offsetof(struct vmcb_seg, attrib),
4842 ((sc->flags >> 8) & 0xff) | ((sc->flags >> 12) & 0x0f00));
4843 }
4844
4845 static inline void svm_load_seg(target_phys_addr_t addr, SegmentCache *sc)
4846 {
4847 unsigned int flags;
4848
4849 sc->selector = lduw_phys(addr + offsetof(struct vmcb_seg, selector));
4850 sc->base = ldq_phys(addr + offsetof(struct vmcb_seg, base));
4851 sc->limit = ldl_phys(addr + offsetof(struct vmcb_seg, limit));
4852 flags = lduw_phys(addr + offsetof(struct vmcb_seg, attrib));
4853 sc->flags = ((flags & 0xff) << 8) | ((flags & 0x0f00) << 12);
4854 }
4855
4856 static inline void svm_load_seg_cache(target_phys_addr_t addr,
4857 CPUState *env, int seg_reg)
4858 {
4859 SegmentCache sc1, *sc = &sc1;
4860 svm_load_seg(addr, sc);
4861 cpu_x86_load_seg_cache(env, seg_reg, sc->selector,
4862 sc->base, sc->limit, sc->flags);
4863 }
4864
4865 void helper_vmrun(int aflag, int next_eip_addend)
4866 {
4867 target_ulong addr;
4868 uint32_t event_inj;
4869 uint32_t int_ctl;
4870
4871 helper_svm_check_intercept_param(SVM_EXIT_VMRUN, 0);
4872
4873 if (aflag == 2)
4874 addr = EAX;
4875 else
4876 addr = (uint32_t)EAX;
4877
4878 qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmrun! " TARGET_FMT_lx "\n", addr);
4879
4880 env->vm_vmcb = addr;
4881
4882 /* save the current CPU state in the hsave page */
4883 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.base), env->gdt.base);
4884 stl_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.limit), env->gdt.limit);
4885
4886 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.base), env->idt.base);
4887 stl_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.limit), env->idt.limit);
4888
4889 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr0), env->cr[0]);
4890 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr2), env->cr[2]);
4891 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr3), env->cr[3]);
4892 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr4), env->cr[4]);
4893 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr6), env->dr[6]);
4894 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr7), env->dr[7]);
4895
4896 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.efer), env->efer);
4897 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rflags), compute_eflags());
4898
4899 svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.es),
4900 &env->segs[R_ES]);
4901 svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.cs),
4902 &env->segs[R_CS]);
4903 svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.ss),
4904 &env->segs[R_SS]);
4905 svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.ds),
4906 &env->segs[R_DS]);
4907
4908 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rip),
4909 EIP + next_eip_addend);
4910 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rsp), ESP);
4911 stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rax), EAX);
4912
4913 /* load the interception bitmaps so we do not need to access the
4914 vmcb in svm mode */
4915 env->intercept = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept));
4916 env->intercept_cr_read = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_cr_read));
4917 env->intercept_cr_write = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_cr_write));
4918 env->intercept_dr_read = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_dr_read));
4919 env->intercept_dr_write = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_dr_write));
4920 env->intercept_exceptions = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_exceptions));
4921
4922 /* enable intercepts */
4923 env->hflags |= HF_SVMI_MASK;
4924
4925 env->tsc_offset = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.tsc_offset));
4926
4927 env->gdt.base = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.base));
4928 env->gdt.limit = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.limit));
4929
4930 env->idt.base = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.base));
4931 env->idt.limit = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.limit));
4932
4933 /* clear exit_info_2 so we behave like the real hardware */
4934 stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2), 0);
4935
4936 cpu_x86_update_cr0(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr0)));
4937 cpu_x86_update_cr4(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr4)));
4938 cpu_x86_update_cr3(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr3)));
4939 env->cr[2] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr2));
4940 int_ctl = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl));
4941 env->hflags2 &= ~(HF2_HIF_MASK | HF2_VINTR_MASK);
4942 if (int_ctl & V_INTR_MASKING_MASK) {
4943 env->v_tpr = int_ctl & V_TPR_MASK;
4944 env->hflags2 |= HF2_VINTR_MASK;
4945 if (env->eflags & IF_MASK)
4946 env->hflags2 |= HF2_HIF_MASK;
4947 }
4948
4949 cpu_load_efer(env,
4950 ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.efer)));
4951 env->eflags = 0;
4952 load_eflags(ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rflags)),
4953 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
4954 CC_OP = CC_OP_EFLAGS;
4955
4956 svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.es),
4957 env, R_ES);
4958 svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.cs),
4959 env, R_CS);
4960 svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.ss),
4961 env, R_SS);
4962 svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.ds),
4963 env, R_DS);
4964
4965 EIP = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rip));
4966 env->eip = EIP;
4967 ESP = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rsp));
4968 EAX = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rax));
4969 env->dr[7] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr7));
4970 env->dr[6] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr6));
4971 cpu_x86_set_cpl(env, ldub_phys(env->vm_vmcb + offsetof(struct vmcb, save.cpl)));
4972
4973 /* FIXME: guest state consistency checks */
4974
4975 switch(ldub_phys(env->vm_vmcb + offsetof(struct vmcb, control.tlb_ctl))) {
4976 case TLB_CONTROL_DO_NOTHING:
4977 break;
4978 case TLB_CONTROL_FLUSH_ALL_ASID:
4979 /* FIXME: this is not 100% correct but should work for now */
4980 tlb_flush(env, 1);
4981 break;
4982 }
4983
4984 env->hflags2 |= HF2_GIF_MASK;
4985
4986 if (int_ctl & V_IRQ_MASK) {
4987 env->interrupt_request |= CPU_INTERRUPT_VIRQ;
4988 }
4989
4990 /* maybe we need to inject an event */
4991 event_inj = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj));
4992 if (event_inj & SVM_EVTINJ_VALID) {
4993 uint8_t vector = event_inj & SVM_EVTINJ_VEC_MASK;
4994 uint16_t valid_err = event_inj & SVM_EVTINJ_VALID_ERR;
4995 uint32_t event_inj_err = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj_err));
4996 stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj), event_inj & ~SVM_EVTINJ_VALID);
4997
4998 qemu_log_mask(CPU_LOG_TB_IN_ASM, "Injecting(%#hx): ", valid_err);
4999 /* FIXME: need to implement valid_err */
5000 switch (event_inj & SVM_EVTINJ_TYPE_MASK) {
5001 case SVM_EVTINJ_TYPE_INTR:
5002 env->exception_index = vector;
5003 env->error_code = event_inj_err;
5004 env->exception_is_int = 0;
5005 env->exception_next_eip = -1;
5006 qemu_log_mask(CPU_LOG_TB_IN_ASM, "INTR");
5007 /* XXX: is it always correct ? */
5008 do_interrupt(vector, 0, 0, 0, 1);
5009 break;
5010 case SVM_EVTINJ_TYPE_NMI:
5011 env->exception_index = EXCP02_NMI;
5012 env->error_code = event_inj_err;
5013 env->exception_is_int = 0;
5014 env->exception_next_eip = EIP;
5015 qemu_log_mask(CPU_LOG_TB_IN_ASM, "NMI");
5016 cpu_loop_exit();
5017 break;
5018 case SVM_EVTINJ_TYPE_EXEPT:
5019 env->exception_index = vector;
5020 env->error_code = event_inj_err;
5021 env->exception_is_int = 0;
5022 env->exception_next_eip = -1;
5023 qemu_log_mask(CPU_LOG_TB_IN_ASM, "EXEPT");
5024 cpu_loop_exit();
5025 break;
5026 case SVM_EVTINJ_TYPE_SOFT:
5027 env->exception_index = vector;
5028 env->error_code = event_inj_err;
5029 env->exception_is_int = 1;
5030 env->exception_next_eip = EIP;
5031 qemu_log_mask(CPU_LOG_TB_IN_ASM, "SOFT");
5032 cpu_loop_exit();
5033 break;
5034 }
5035 qemu_log_mask(CPU_LOG_TB_IN_ASM, " %#x %#x\n", env->exception_index, env->error_code);
5036 }
5037 }
5038
5039 void helper_vmmcall(void)
5040 {
5041 helper_svm_check_intercept_param(SVM_EXIT_VMMCALL, 0);
5042 raise_exception(EXCP06_ILLOP);
5043 }
5044
5045 void helper_vmload(int aflag)
5046 {
5047 target_ulong addr;
5048 helper_svm_check_intercept_param(SVM_EXIT_VMLOAD, 0);
5049
5050 if (aflag == 2)
5051 addr = EAX;
5052 else
5053 addr = (uint32_t)EAX;
5054
5055 qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmload! " TARGET_FMT_lx "\nFS: %016" PRIx64 " | " TARGET_FMT_lx "\n",
5056 addr, ldq_phys(addr + offsetof(struct vmcb, save.fs.base)),
5057 env->segs[R_FS].base);
5058
5059 svm_load_seg_cache(addr + offsetof(struct vmcb, save.fs),
5060 env, R_FS);
5061 svm_load_seg_cache(addr + offsetof(struct vmcb, save.gs),
5062 env, R_GS);
5063 svm_load_seg(addr + offsetof(struct vmcb, save.tr),
5064 &env->tr);
5065 svm_load_seg(addr + offsetof(struct vmcb, save.ldtr),
5066 &env->ldt);
5067
5068 #ifdef TARGET_X86_64
5069 env->kernelgsbase = ldq_phys(addr + offsetof(struct vmcb, save.kernel_gs_base));
5070 env->lstar = ldq_phys(addr + offsetof(struct vmcb, save.lstar));
5071 env->cstar = ldq_phys(addr + offsetof(struct vmcb, save.cstar));
5072 env->fmask = ldq_phys(addr + offsetof(struct vmcb, save.sfmask));
5073 #endif
5074 env->star = ldq_phys(addr + offsetof(struct vmcb, save.star));
5075 env->sysenter_cs = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_cs));
5076 env->sysenter_esp = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_esp));
5077 env->sysenter_eip = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_eip));
5078 }
5079
5080 void helper_vmsave(int aflag)
5081 {
5082 target_ulong addr;
5083 helper_svm_check_intercept_param(SVM_EXIT_VMSAVE, 0);
5084
5085 if (aflag == 2)
5086 addr = EAX;
5087 else
5088 addr = (uint32_t)EAX;
5089
5090 qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmsave! " TARGET_FMT_lx "\nFS: %016" PRIx64 " | " TARGET_FMT_lx "\n",
5091 addr, ldq_phys(addr + offsetof(struct vmcb, save.fs.base)),
5092 env->segs[R_FS].base);
5093
5094 svm_save_seg(addr + offsetof(struct vmcb, save.fs),
5095 &env->segs[R_FS]);
5096 svm_save_seg(addr + offsetof(struct vmcb, save.gs),
5097 &env->segs[R_GS]);
5098 svm_save_seg(addr + offsetof(struct vmcb, save.tr),
5099 &env->tr);
5100 svm_save_seg(addr + offsetof(struct vmcb, save.ldtr),
5101 &env->ldt);
5102
5103 #ifdef TARGET_X86_64
5104 stq_phys(addr + offsetof(struct vmcb, save.kernel_gs_base), env->kernelgsbase);
5105 stq_phys(addr + offsetof(struct vmcb, save.lstar), env->lstar);
5106 stq_phys(addr + offsetof(struct vmcb, save.cstar), env->cstar);
5107 stq_phys(addr + offsetof(struct vmcb, save.sfmask), env->fmask);
5108 #endif
5109 stq_phys(addr + offsetof(struct vmcb, save.star), env->star);
5110 stq_phys(addr + offsetof(struct vmcb, save.sysenter_cs), env->sysenter_cs);
5111 stq_phys(addr + offsetof(struct vmcb, save.sysenter_esp), env->sysenter_esp);
5112 stq_phys(addr + offsetof(struct vmcb, save.sysenter_eip), env->sysenter_eip);
5113 }
5114
5115 void helper_stgi(void)
5116 {
5117 helper_svm_check_intercept_param(SVM_EXIT_STGI, 0);
5118 env->hflags2 |= HF2_GIF_MASK;
5119 }
5120
5121 void helper_clgi(void)
5122 {
5123 helper_svm_check_intercept_param(SVM_EXIT_CLGI, 0);
5124 env->hflags2 &= ~HF2_GIF_MASK;
5125 }
5126
5127 void helper_skinit(void)
5128 {
5129 helper_svm_check_intercept_param(SVM_EXIT_SKINIT, 0);
5130 /* XXX: not implemented */
5131 raise_exception(EXCP06_ILLOP);
5132 }
5133
5134 void helper_invlpga(int aflag)
5135 {
5136 target_ulong addr;
5137 helper_svm_check_intercept_param(SVM_EXIT_INVLPGA, 0);
5138
5139 if (aflag == 2)
5140 addr = EAX;
5141 else
5142 addr = (uint32_t)EAX;
5143
5144 /* XXX: could use the ASID to see if it is needed to do the
5145 flush */
5146 tlb_flush_page(env, addr);
5147 }
5148
5149 void helper_svm_check_intercept_param(uint32_t type, uint64_t param)
5150 {
5151 if (likely(!(env->hflags & HF_SVMI_MASK)))
5152 return;
5153 switch(type) {
5154 case SVM_EXIT_READ_CR0 ... SVM_EXIT_READ_CR0 + 8:
5155 if (env->intercept_cr_read & (1 << (type - SVM_EXIT_READ_CR0))) {
5156 helper_vmexit(type, param);
5157 }
5158 break;
5159 case SVM_EXIT_WRITE_CR0 ... SVM_EXIT_WRITE_CR0 + 8:
5160 if (env->intercept_cr_write & (1 << (type - SVM_EXIT_WRITE_CR0))) {
5161 helper_vmexit(type, param);
5162 }
5163 break;
5164 case SVM_EXIT_READ_DR0 ... SVM_EXIT_READ_DR0 + 7:
5165 if (env->intercept_dr_read & (1 << (type - SVM_EXIT_READ_DR0))) {
5166 helper_vmexit(type, param);
5167 }
5168 break;
5169 case SVM_EXIT_WRITE_DR0 ... SVM_EXIT_WRITE_DR0 + 7:
5170 if (env->intercept_dr_write & (1 << (type - SVM_EXIT_WRITE_DR0))) {
5171 helper_vmexit(type, param);
5172 }
5173 break;
5174 case SVM_EXIT_EXCP_BASE ... SVM_EXIT_EXCP_BASE + 31:
5175 if (env->intercept_exceptions & (1 << (type - SVM_EXIT_EXCP_BASE))) {
5176 helper_vmexit(type, param);
5177 }
5178 break;
5179 case SVM_EXIT_MSR:
5180 if (env->intercept & (1ULL << (SVM_EXIT_MSR - SVM_EXIT_INTR))) {
5181 /* FIXME: this should be read in at vmrun (faster this way?) */
5182 uint64_t addr = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.msrpm_base_pa));
5183 uint32_t t0, t1;
5184 switch((uint32_t)ECX) {
5185 case 0 ... 0x1fff:
5186 t0 = (ECX * 2) % 8;
5187 t1 = ECX / 8;
5188 break;
5189 case 0xc0000000 ... 0xc0001fff:
5190 t0 = (8192 + ECX - 0xc0000000) * 2;
5191 t1 = (t0 / 8);
5192 t0 %= 8;
5193 break;
5194 case 0xc0010000 ... 0xc0011fff:
5195 t0 = (16384 + ECX - 0xc0010000) * 2;
5196 t1 = (t0 / 8);
5197 t0 %= 8;
5198 break;
5199 default:
5200 helper_vmexit(type, param);
5201 t0 = 0;
5202 t1 = 0;
5203 break;
5204 }
5205 if (ldub_phys(addr + t1) & ((1 << param) << t0))
5206 helper_vmexit(type, param);
5207 }
5208 break;
5209 default:
5210 if (env->intercept & (1ULL << (type - SVM_EXIT_INTR))) {
5211 helper_vmexit(type, param);
5212 }
5213 break;
5214 }
5215 }
5216
5217 void helper_svm_check_io(uint32_t port, uint32_t param,
5218 uint32_t next_eip_addend)
5219 {
5220 if (env->intercept & (1ULL << (SVM_EXIT_IOIO - SVM_EXIT_INTR))) {
5221 /* FIXME: this should be read in at vmrun (faster this way?) */
5222 uint64_t addr = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.iopm_base_pa));
5223 uint16_t mask = (1 << ((param >> 4) & 7)) - 1;
5224 if(lduw_phys(addr + port / 8) & (mask << (port & 7))) {
5225 /* next EIP */
5226 stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2),
5227 env->eip + next_eip_addend);
5228 helper_vmexit(SVM_EXIT_IOIO, param | (port << 16));
5229 }
5230 }
5231 }
5232
5233 /* Note: currently only 32 bits of exit_code are used */
5234 void helper_vmexit(uint32_t exit_code, uint64_t exit_info_1)
5235 {
5236 uint32_t int_ctl;
5237
5238 qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmexit(%08x, %016" PRIx64 ", %016" PRIx64 ", " TARGET_FMT_lx ")!\n",
5239 exit_code, exit_info_1,
5240 ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2)),
5241 EIP);
5242
5243 if(env->hflags & HF_INHIBIT_IRQ_MASK) {
5244 stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_state), SVM_INTERRUPT_SHADOW_MASK);
5245 env->hflags &= ~HF_INHIBIT_IRQ_MASK;
5246 } else {
5247 stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_state), 0);
5248 }
5249
5250 /* Save the VM state in the vmcb */
5251 svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.es),
5252 &env->segs[R_ES]);
5253 svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.cs),
5254 &env->segs[R_CS]);
5255 svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.ss),
5256 &env->segs[R_SS]);
5257 svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.ds),
5258 &env->segs[R_DS]);
5259
5260 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.base), env->gdt.base);
5261 stl_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.limit), env->gdt.limit);
5262
5263 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.base), env->idt.base);
5264 stl_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.limit), env->idt.limit);
5265
5266 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.efer), env->efer);
5267 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr0), env->cr[0]);
5268 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr2), env->cr[2]);
5269 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr3), env->cr[3]);
5270 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr4), env->cr[4]);
5271
5272 int_ctl = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl));
5273 int_ctl &= ~(V_TPR_MASK | V_IRQ_MASK);
5274 int_ctl |= env->v_tpr & V_TPR_MASK;
5275 if (env->interrupt_request & CPU_INTERRUPT_VIRQ)
5276 int_ctl |= V_IRQ_MASK;
5277 stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl), int_ctl);
5278
5279 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rflags), compute_eflags());
5280 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rip), env->eip);
5281 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rsp), ESP);
5282 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rax), EAX);
5283 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr7), env->dr[7]);
5284 stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr6), env->dr[6]);
5285 stb_phys(env->vm_vmcb + offsetof(struct vmcb, save.cpl), env->hflags & HF_CPL_MASK);
5286
5287 /* Reload the host state from vm_hsave */
5288 env->hflags2 &= ~(HF2_HIF_MASK | HF2_VINTR_MASK);
5289 env->hflags &= ~HF_SVMI_MASK;
5290 env->intercept = 0;
5291 env->intercept_exceptions = 0;
5292 env->interrupt_request &= ~CPU_INTERRUPT_VIRQ;
5293 env->tsc_offset = 0;
5294
5295 env->gdt.base = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.base));
5296 env->gdt.limit = ldl_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.limit));
5297
5298 env->idt.base = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.base));
5299 env->idt.limit = ldl_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.limit));
5300
5301 cpu_x86_update_cr0(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr0)) | CR0_PE_MASK);
5302 cpu_x86_update_cr4(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr4)));
5303 cpu_x86_update_cr3(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr3)));
5304 /* we need to set the efer after the crs so the hidden flags get
5305 set properly */
5306 cpu_load_efer(env,
5307 ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.efer)));
5308 env->eflags = 0;
5309 load_eflags(ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rflags)),
5310 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
5311 CC_OP = CC_OP_EFLAGS;
5312
5313 svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.es),
5314 env, R_ES);
5315 svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.cs),
5316 env, R_CS);
5317 svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.ss),
5318 env, R_SS);
5319 svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.ds),
5320 env, R_DS);
5321
5322 EIP = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rip));
5323 ESP = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rsp));
5324 EAX = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rax));
5325
5326 env->dr[6] = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr6));
5327 env->dr[7] = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr7));
5328
5329 /* other setups */
5330 cpu_x86_set_cpl(env, 0);
5331 stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_code), exit_code);
5332 stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_1), exit_info_1);
5333
5334 env->hflags2 &= ~HF2_GIF_MASK;
5335 /* FIXME: Resets the current ASID register to zero (host ASID). */
5336
5337 /* Clears the V_IRQ and V_INTR_MASKING bits inside the processor. */
5338
5339 /* Clears the TSC_OFFSET inside the processor. */
5340
5341 /* If the host is in PAE mode, the processor reloads the host's PDPEs
5342 from the page table indicated the host's CR3. If the PDPEs contain
5343 illegal state, the processor causes a shutdown. */
5344
5345 /* Forces CR0.PE = 1, RFLAGS.VM = 0. */
5346 env->cr[0] |= CR0_PE_MASK;
5347 env->eflags &= ~VM_MASK;
5348
5349 /* Disables all breakpoints in the host DR7 register. */
5350
5351 /* Checks the reloaded host state for consistency. */
5352
5353 /* If the host's rIP reloaded by #VMEXIT is outside the limit of the
5354 host's code segment or non-canonical (in the case of long mode), a
5355 #GP fault is delivered inside the host.) */
5356
5357 /* remove any pending exception */
5358 env->exception_index = -1;
5359 env->error_code = 0;
5360 env->old_exception = -1;
5361
5362 cpu_loop_exit();
5363 }
5364
5365 #endif
5366
5367 /* MMX/SSE */
5368 /* XXX: optimize by storing fptt and fptags in the static cpu state */
5369 void helper_enter_mmx(void)
5370 {
5371 env->fpstt = 0;
5372 *(uint32_t *)(env->fptags) = 0;
5373 *(uint32_t *)(env->fptags + 4) = 0;
5374 }
5375
5376 void helper_emms(void)
5377 {
5378 /* set to empty state */
5379 *(uint32_t *)(env->fptags) = 0x01010101;
5380 *(uint32_t *)(env->fptags + 4) = 0x01010101;
5381 }
5382
5383 /* XXX: suppress */
5384 void helper_movq(void *d, void *s)
5385 {
5386 *(uint64_t *)d = *(uint64_t *)s;
5387 }
5388
5389 #define SHIFT 0
5390 #include "ops_sse.h"
5391
5392 #define SHIFT 1
5393 #include "ops_sse.h"
5394
5395 #define SHIFT 0
5396 #include "helper_template.h"
5397 #undef SHIFT
5398
5399 #define SHIFT 1
5400 #include "helper_template.h"
5401 #undef SHIFT
5402
5403 #define SHIFT 2
5404 #include "helper_template.h"
5405 #undef SHIFT
5406
5407 #ifdef TARGET_X86_64
5408
5409 #define SHIFT 3
5410 #include "helper_template.h"
5411 #undef SHIFT
5412
5413 #endif
5414
5415 /* bit operations */
5416 target_ulong helper_bsf(target_ulong t0)
5417 {
5418 int count;
5419 target_ulong res;
5420
5421 res = t0;
5422 count = 0;
5423 while ((res & 1) == 0) {
5424 count++;
5425 res >>= 1;
5426 }
5427 return count;
5428 }
5429
5430 target_ulong helper_bsr(target_ulong t0)
5431 {
5432 int count;
5433 target_ulong res, mask;
5434
5435 res = t0;
5436 count = TARGET_LONG_BITS - 1;
5437 mask = (target_ulong)1 << (TARGET_LONG_BITS - 1);
5438 while ((res & mask) == 0) {
5439 count--;
5440 res <<= 1;
5441 }
5442 return count;
5443 }
5444
5445
5446 static int compute_all_eflags(void)
5447 {
5448 return CC_SRC;
5449 }
5450
5451 static int compute_c_eflags(void)
5452 {
5453 return CC_SRC & CC_C;
5454 }
5455
5456 uint32_t helper_cc_compute_all(int op)
5457 {
5458 switch (op) {
5459 default: /* should never happen */ return 0;
5460
5461 case CC_OP_EFLAGS: return compute_all_eflags();
5462
5463 case CC_OP_MULB: return compute_all_mulb();
5464 case CC_OP_MULW: return compute_all_mulw();
5465 case CC_OP_MULL: return compute_all_mull();
5466
5467 case CC_OP_ADDB: return compute_all_addb();
5468 case CC_OP_ADDW: return compute_all_addw();
5469 case CC_OP_ADDL: return compute_all_addl();
5470
5471 case CC_OP_ADCB: return compute_all_adcb();
5472 case CC_OP_ADCW: return compute_all_adcw();
5473 case CC_OP_ADCL: return compute_all_adcl();
5474
5475 case CC_OP_SUBB: return compute_all_subb();
5476 case CC_OP_SUBW: return compute_all_subw();
5477 case CC_OP_SUBL: return compute_all_subl();
5478
5479 case CC_OP_SBBB: return compute_all_sbbb();
5480 case CC_OP_SBBW: return compute_all_sbbw();
5481 case CC_OP_SBBL: return compute_all_sbbl();
5482
5483 case CC_OP_LOGICB: return compute_all_logicb();
5484 case CC_OP_LOGICW: return compute_all_logicw();
5485 case CC_OP_LOGICL: return compute_all_logicl();
5486
5487 case CC_OP_INCB: return compute_all_incb();
5488 case CC_OP_INCW: return compute_all_incw();
5489 case CC_OP_INCL: return compute_all_incl();
5490
5491 case CC_OP_DECB: return compute_all_decb();
5492 case CC_OP_DECW: return compute_all_decw();
5493 case CC_OP_DECL: return compute_all_decl();
5494
5495 case CC_OP_SHLB: return compute_all_shlb();
5496 case CC_OP_SHLW: return compute_all_shlw();
5497 case CC_OP_SHLL: return compute_all_shll();
5498
5499 case CC_OP_SARB: return compute_all_sarb();
5500 case CC_OP_SARW: return compute_all_sarw();
5501 case CC_OP_SARL: return compute_all_sarl();
5502
5503 #ifdef TARGET_X86_64
5504 case CC_OP_MULQ: return compute_all_mulq();
5505
5506 case CC_OP_ADDQ: return compute_all_addq();
5507
5508 case CC_OP_ADCQ: return compute_all_adcq();
5509
5510 case CC_OP_SUBQ: return compute_all_subq();
5511
5512 case CC_OP_SBBQ: return compute_all_sbbq();
5513
5514 case CC_OP_LOGICQ: return compute_all_logicq();
5515
5516 case CC_OP_INCQ: return compute_all_incq();
5517
5518 case CC_OP_DECQ: return compute_all_decq();
5519
5520 case CC_OP_SHLQ: return compute_all_shlq();
5521
5522 case CC_OP_SARQ: return compute_all_sarq();
5523 #endif
5524 }
5525 }
5526
5527 uint32_t helper_cc_compute_c(int op)
5528 {
5529 switch (op) {
5530 default: /* should never happen */ return 0;
5531
5532 case CC_OP_EFLAGS: return compute_c_eflags();
5533
5534 case CC_OP_MULB: return compute_c_mull();
5535 case CC_OP_MULW: return compute_c_mull();
5536 case CC_OP_MULL: return compute_c_mull();
5537
5538 case CC_OP_ADDB: return compute_c_addb();
5539 case CC_OP_ADDW: return compute_c_addw();
5540 case CC_OP_ADDL: return compute_c_addl();
5541
5542 case CC_OP_ADCB: return compute_c_adcb();
5543 case CC_OP_ADCW: return compute_c_adcw();
5544 case CC_OP_ADCL: return compute_c_adcl();
5545
5546 case CC_OP_SUBB: return compute_c_subb();
5547 case CC_OP_SUBW: return compute_c_subw();
5548 case CC_OP_SUBL: return compute_c_subl();
5549
5550 case CC_OP_SBBB: return compute_c_sbbb();
5551 case CC_OP_SBBW: return compute_c_sbbw();
5552 case CC_OP_SBBL: return compute_c_sbbl();
5553
5554 case CC_OP_LOGICB: return compute_c_logicb();
5555 case CC_OP_LOGICW: return compute_c_logicw();
5556 case CC_OP_LOGICL: return compute_c_logicl();
5557
5558 case CC_OP_INCB: return compute_c_incl();
5559 case CC_OP_INCW: return compute_c_incl();
5560 case CC_OP_INCL: return compute_c_incl();
5561
5562 case CC_OP_DECB: return compute_c_incl();
5563 case CC_OP_DECW: return compute_c_incl();
5564 case CC_OP_DECL: return compute_c_incl();
5565
5566 case CC_OP_SHLB: return compute_c_shlb();
5567 case CC_OP_SHLW: return compute_c_shlw();
5568 case CC_OP_SHLL: return compute_c_shll();
5569
5570 case CC_OP_SARB: return compute_c_sarl();
5571 case CC_OP_SARW: return compute_c_sarl();
5572 case CC_OP_SARL: return compute_c_sarl();
5573
5574 #ifdef TARGET_X86_64
5575 case CC_OP_MULQ: return compute_c_mull();
5576
5577 case CC_OP_ADDQ: return compute_c_addq();
5578
5579 case CC_OP_ADCQ: return compute_c_adcq();
5580
5581 case CC_OP_SUBQ: return compute_c_subq();
5582
5583 case CC_OP_SBBQ: return compute_c_sbbq();
5584
5585 case CC_OP_LOGICQ: return compute_c_logicq();
5586
5587 case CC_OP_INCQ: return compute_c_incl();
5588
5589 case CC_OP_DECQ: return compute_c_incl();
5590
5591 case CC_OP_SHLQ: return compute_c_shlq();
5592
5593 case CC_OP_SARQ: return compute_c_sarl();
5594 #endif
5595 }
5596 }
Qemu copy for testing