![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op_helper.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-i386|
Return to op_helper.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-i386 |
1.1 root 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: qemu_log_mask(CPU_LOG_RESET, "Triple fault\n");
1279:
1280: qemu_system_reset_request();
1281: return EXCP_HLT;
1282: }
1283: #endif
1284:
1285: if ((first_contributory && second_contributory)
1286: || (env->old_exception == EXCP0E_PAGE &&
1287: (second_contributory || (intno == EXCP0E_PAGE)))) {
1288: intno = EXCP08_DBLE;
1289: *error_code = 0;
1290: }
1291:
1292: if (second_contributory || (intno == EXCP0E_PAGE) ||
1293: (intno == EXCP08_DBLE))
1294: env->old_exception = intno;
1295:
1296: return intno;
1297: }
1298:
1299: /*
1300: * Signal an interruption. It is executed in the main CPU loop.
1301: * is_int is TRUE if coming from the int instruction. next_eip is the
1302: * EIP value AFTER the interrupt instruction. It is only relevant if
1303: * is_int is TRUE.
1304: */
1305: static void QEMU_NORETURN raise_interrupt(int intno, int is_int, int error_code,
1306: int next_eip_addend)
1307: {
1308: if (!is_int) {
1309: helper_svm_check_intercept_param(SVM_EXIT_EXCP_BASE + intno, error_code);
1310: intno = check_exception(intno, &error_code);
1311: } else {
1312: helper_svm_check_intercept_param(SVM_EXIT_SWINT, 0);
1313: }
1314:
1315: env->exception_index = intno;
1316: env->error_code = error_code;
1317: env->exception_is_int = is_int;
1318: env->exception_next_eip = env->eip + next_eip_addend;
1319: cpu_loop_exit();
1320: }
1321:
1322: /* shortcuts to generate exceptions */
1323:
1324: void raise_exception_err(int exception_index, int error_code)
1325: {
1326: raise_interrupt(exception_index, 0, error_code, 0);
1327: }
1328:
1329: void raise_exception(int exception_index)
1330: {
1331: raise_interrupt(exception_index, 0, 0, 0);
1332: }
1333:
1334: /* SMM support */
1335:
1336: #if defined(CONFIG_USER_ONLY)
1337:
1338: void do_smm_enter(void)
1339: {
1340: }
1341:
1342: void helper_rsm(void)
1343: {
1344: }
1345:
1346: #else
1347:
1348: #ifdef TARGET_X86_64
1349: #define SMM_REVISION_ID 0x00020064
1350: #else
1351: #define SMM_REVISION_ID 0x00020000
1352: #endif
1353:
1354: void do_smm_enter(void)
1355: {
1356: target_ulong sm_state;
1357: SegmentCache *dt;
1358: int i, offset;
1359:
1360: qemu_log_mask(CPU_LOG_INT, "SMM: enter\n");
1361: log_cpu_state_mask(CPU_LOG_INT, env, X86_DUMP_CCOP);
1362:
1363: env->hflags |= HF_SMM_MASK;
1364: cpu_smm_update(env);
1365:
1366: sm_state = env->smbase + 0x8000;
1367:
1368: #ifdef TARGET_X86_64
1369: for(i = 0; i < 6; i++) {
1370: dt = &env->segs[i];
1371: offset = 0x7e00 + i * 16;
1372: stw_phys(sm_state + offset, dt->selector);
1373: stw_phys(sm_state + offset + 2, (dt->flags >> 8) & 0xf0ff);
1374: stl_phys(sm_state + offset + 4, dt->limit);
1375: stq_phys(sm_state + offset + 8, dt->base);
1376: }
1377:
1378: stq_phys(sm_state + 0x7e68, env->gdt.base);
1379: stl_phys(sm_state + 0x7e64, env->gdt.limit);
1380:
1381: stw_phys(sm_state + 0x7e70, env->ldt.selector);
1382: stq_phys(sm_state + 0x7e78, env->ldt.base);
1383: stl_phys(sm_state + 0x7e74, env->ldt.limit);
1384: stw_phys(sm_state + 0x7e72, (env->ldt.flags >> 8) & 0xf0ff);
1385:
1386: stq_phys(sm_state + 0x7e88, env->idt.base);
1387: stl_phys(sm_state + 0x7e84, env->idt.limit);
1388:
1389: stw_phys(sm_state + 0x7e90, env->tr.selector);
1390: stq_phys(sm_state + 0x7e98, env->tr.base);
1391: stl_phys(sm_state + 0x7e94, env->tr.limit);
1392: stw_phys(sm_state + 0x7e92, (env->tr.flags >> 8) & 0xf0ff);
1393:
1394: stq_phys(sm_state + 0x7ed0, env->efer);
1395:
1396: stq_phys(sm_state + 0x7ff8, EAX);
1397: stq_phys(sm_state + 0x7ff0, ECX);
1398: stq_phys(sm_state + 0x7fe8, EDX);
1399: stq_phys(sm_state + 0x7fe0, EBX);
1400: stq_phys(sm_state + 0x7fd8, ESP);
1401: stq_phys(sm_state + 0x7fd0, EBP);
1402: stq_phys(sm_state + 0x7fc8, ESI);
1403: stq_phys(sm_state + 0x7fc0, EDI);
1404: for(i = 8; i < 16; i++)
1405: stq_phys(sm_state + 0x7ff8 - i * 8, env->regs[i]);
1406: stq_phys(sm_state + 0x7f78, env->eip);
1407: stl_phys(sm_state + 0x7f70, compute_eflags());
1408: stl_phys(sm_state + 0x7f68, env->dr[6]);
1409: stl_phys(sm_state + 0x7f60, env->dr[7]);
1410:
1411: stl_phys(sm_state + 0x7f48, env->cr[4]);
1412: stl_phys(sm_state + 0x7f50, env->cr[3]);
1413: stl_phys(sm_state + 0x7f58, env->cr[0]);
1414:
1415: stl_phys(sm_state + 0x7efc, SMM_REVISION_ID);
1416: stl_phys(sm_state + 0x7f00, env->smbase);
1417: #else
1418: stl_phys(sm_state + 0x7ffc, env->cr[0]);
1419: stl_phys(sm_state + 0x7ff8, env->cr[3]);
1420: stl_phys(sm_state + 0x7ff4, compute_eflags());
1421: stl_phys(sm_state + 0x7ff0, env->eip);
1422: stl_phys(sm_state + 0x7fec, EDI);
1423: stl_phys(sm_state + 0x7fe8, ESI);
1424: stl_phys(sm_state + 0x7fe4, EBP);
1425: stl_phys(sm_state + 0x7fe0, ESP);
1426: stl_phys(sm_state + 0x7fdc, EBX);
1427: stl_phys(sm_state + 0x7fd8, EDX);
1428: stl_phys(sm_state + 0x7fd4, ECX);
1429: stl_phys(sm_state + 0x7fd0, EAX);
1430: stl_phys(sm_state + 0x7fcc, env->dr[6]);
1431: stl_phys(sm_state + 0x7fc8, env->dr[7]);
1432:
1433: stl_phys(sm_state + 0x7fc4, env->tr.selector);
1434: stl_phys(sm_state + 0x7f64, env->tr.base);
1435: stl_phys(sm_state + 0x7f60, env->tr.limit);
1436: stl_phys(sm_state + 0x7f5c, (env->tr.flags >> 8) & 0xf0ff);
1437:
1438: stl_phys(sm_state + 0x7fc0, env->ldt.selector);
1439: stl_phys(sm_state + 0x7f80, env->ldt.base);
1440: stl_phys(sm_state + 0x7f7c, env->ldt.limit);
1441: stl_phys(sm_state + 0x7f78, (env->ldt.flags >> 8) & 0xf0ff);
1442:
1443: stl_phys(sm_state + 0x7f74, env->gdt.base);
1444: stl_phys(sm_state + 0x7f70, env->gdt.limit);
1445:
1446: stl_phys(sm_state + 0x7f58, env->idt.base);
1447: stl_phys(sm_state + 0x7f54, env->idt.limit);
1448:
1449: for(i = 0; i < 6; i++) {
1450: dt = &env->segs[i];
1451: if (i < 3)
1452: offset = 0x7f84 + i * 12;
1453: else
1454: offset = 0x7f2c + (i - 3) * 12;
1455: stl_phys(sm_state + 0x7fa8 + i * 4, dt->selector);
1456: stl_phys(sm_state + offset + 8, dt->base);
1457: stl_phys(sm_state + offset + 4, dt->limit);
1458: stl_phys(sm_state + offset, (dt->flags >> 8) & 0xf0ff);
1459: }
1460: stl_phys(sm_state + 0x7f14, env->cr[4]);
1461:
1462: stl_phys(sm_state + 0x7efc, SMM_REVISION_ID);
1463: stl_phys(sm_state + 0x7ef8, env->smbase);
1464: #endif
1465: /* init SMM cpu state */
1466:
1467: #ifdef TARGET_X86_64
1468: cpu_load_efer(env, 0);
1469: #endif
1470: load_eflags(0, ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1471: env->eip = 0x00008000;
1472: cpu_x86_load_seg_cache(env, R_CS, (env->smbase >> 4) & 0xffff, env->smbase,
1473: 0xffffffff, 0);
1474: cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffffffff, 0);
1475: cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffffffff, 0);
1476: cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffffffff, 0);
1477: cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffffffff, 0);
1478: cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffffffff, 0);
1479:
1480: cpu_x86_update_cr0(env,
1481: env->cr[0] & ~(CR0_PE_MASK | CR0_EM_MASK | CR0_TS_MASK | CR0_PG_MASK));
1482: cpu_x86_update_cr4(env, 0);
1483: env->dr[7] = 0x00000400;
1484: CC_OP = CC_OP_EFLAGS;
1485: }
1486:
1487: void helper_rsm(void)
1488: {
1489: target_ulong sm_state;
1490: int i, offset;
1491: uint32_t val;
1492:
1493: sm_state = env->smbase + 0x8000;
1494: #ifdef TARGET_X86_64
1495: cpu_load_efer(env, ldq_phys(sm_state + 0x7ed0));
1496:
1497: for(i = 0; i < 6; i++) {
1498: offset = 0x7e00 + i * 16;
1499: cpu_x86_load_seg_cache(env, i,
1500: lduw_phys(sm_state + offset),
1501: ldq_phys(sm_state + offset + 8),
1502: ldl_phys(sm_state + offset + 4),
1503: (lduw_phys(sm_state + offset + 2) & 0xf0ff) << 8);
1504: }
1505:
1506: env->gdt.base = ldq_phys(sm_state + 0x7e68);
1507: env->gdt.limit = ldl_phys(sm_state + 0x7e64);
1508:
1509: env->ldt.selector = lduw_phys(sm_state + 0x7e70);
1510: env->ldt.base = ldq_phys(sm_state + 0x7e78);
1511: env->ldt.limit = ldl_phys(sm_state + 0x7e74);
1512: env->ldt.flags = (lduw_phys(sm_state + 0x7e72) & 0xf0ff) << 8;
1513:
1514: env->idt.base = ldq_phys(sm_state + 0x7e88);
1515: env->idt.limit = ldl_phys(sm_state + 0x7e84);
1516:
1517: env->tr.selector = lduw_phys(sm_state + 0x7e90);
1518: env->tr.base = ldq_phys(sm_state + 0x7e98);
1519: env->tr.limit = ldl_phys(sm_state + 0x7e94);
1520: env->tr.flags = (lduw_phys(sm_state + 0x7e92) & 0xf0ff) << 8;
1521:
1522: EAX = ldq_phys(sm_state + 0x7ff8);
1523: ECX = ldq_phys(sm_state + 0x7ff0);
1524: EDX = ldq_phys(sm_state + 0x7fe8);
1525: EBX = ldq_phys(sm_state + 0x7fe0);
1526: ESP = ldq_phys(sm_state + 0x7fd8);
1527: EBP = ldq_phys(sm_state + 0x7fd0);
1528: ESI = ldq_phys(sm_state + 0x7fc8);
1529: EDI = ldq_phys(sm_state + 0x7fc0);
1530: for(i = 8; i < 16; i++)
1531: env->regs[i] = ldq_phys(sm_state + 0x7ff8 - i * 8);
1532: env->eip = ldq_phys(sm_state + 0x7f78);
1533: load_eflags(ldl_phys(sm_state + 0x7f70),
1534: ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1535: env->dr[6] = ldl_phys(sm_state + 0x7f68);
1536: env->dr[7] = ldl_phys(sm_state + 0x7f60);
1537:
1538: cpu_x86_update_cr4(env, ldl_phys(sm_state + 0x7f48));
1539: cpu_x86_update_cr3(env, ldl_phys(sm_state + 0x7f50));
1540: cpu_x86_update_cr0(env, ldl_phys(sm_state + 0x7f58));
1541:
1542: val = ldl_phys(sm_state + 0x7efc); /* revision ID */
1543: if (val & 0x20000) {
1544: env->smbase = ldl_phys(sm_state + 0x7f00) & ~0x7fff;
1545: }
1546: #else
1547: cpu_x86_update_cr0(env, ldl_phys(sm_state + 0x7ffc));
1548: cpu_x86_update_cr3(env, ldl_phys(sm_state + 0x7ff8));
1549: load_eflags(ldl_phys(sm_state + 0x7ff4),
1550: ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1551: env->eip = ldl_phys(sm_state + 0x7ff0);
1552: EDI = ldl_phys(sm_state + 0x7fec);
1553: ESI = ldl_phys(sm_state + 0x7fe8);
1554: EBP = ldl_phys(sm_state + 0x7fe4);
1555: ESP = ldl_phys(sm_state + 0x7fe0);
1556: EBX = ldl_phys(sm_state + 0x7fdc);
1557: EDX = ldl_phys(sm_state + 0x7fd8);
1558: ECX = ldl_phys(sm_state + 0x7fd4);
1559: EAX = ldl_phys(sm_state + 0x7fd0);
1560: env->dr[6] = ldl_phys(sm_state + 0x7fcc);
1561: env->dr[7] = ldl_phys(sm_state + 0x7fc8);
1562:
1563: env->tr.selector = ldl_phys(sm_state + 0x7fc4) & 0xffff;
1564: env->tr.base = ldl_phys(sm_state + 0x7f64);
1565: env->tr.limit = ldl_phys(sm_state + 0x7f60);
1566: env->tr.flags = (ldl_phys(sm_state + 0x7f5c) & 0xf0ff) << 8;
1567:
1568: env->ldt.selector = ldl_phys(sm_state + 0x7fc0) & 0xffff;
1569: env->ldt.base = ldl_phys(sm_state + 0x7f80);
1570: env->ldt.limit = ldl_phys(sm_state + 0x7f7c);
1571: env->ldt.flags = (ldl_phys(sm_state + 0x7f78) & 0xf0ff) << 8;
1572:
1573: env->gdt.base = ldl_phys(sm_state + 0x7f74);
1574: env->gdt.limit = ldl_phys(sm_state + 0x7f70);
1575:
1576: env->idt.base = ldl_phys(sm_state + 0x7f58);
1577: env->idt.limit = ldl_phys(sm_state + 0x7f54);
1578:
1579: for(i = 0; i < 6; i++) {
1580: if (i < 3)
1581: offset = 0x7f84 + i * 12;
1582: else
1583: offset = 0x7f2c + (i - 3) * 12;
1584: cpu_x86_load_seg_cache(env, i,
1585: ldl_phys(sm_state + 0x7fa8 + i * 4) & 0xffff,
1586: ldl_phys(sm_state + offset + 8),
1587: ldl_phys(sm_state + offset + 4),
1588: (ldl_phys(sm_state + offset) & 0xf0ff) << 8);
1589: }
1590: cpu_x86_update_cr4(env, ldl_phys(sm_state + 0x7f14));
1591:
1592: val = ldl_phys(sm_state + 0x7efc); /* revision ID */
1593: if (val & 0x20000) {
1594: env->smbase = ldl_phys(sm_state + 0x7ef8) & ~0x7fff;
1595: }
1596: #endif
1597: CC_OP = CC_OP_EFLAGS;
1598: env->hflags &= ~HF_SMM_MASK;
1599: cpu_smm_update(env);
1600:
1601: qemu_log_mask(CPU_LOG_INT, "SMM: after RSM\n");
1602: log_cpu_state_mask(CPU_LOG_INT, env, X86_DUMP_CCOP);
1603: }
1604:
1605: #endif /* !CONFIG_USER_ONLY */
1606:
1607:
1608: /* division, flags are undefined */
1609:
1610: void helper_divb_AL(target_ulong t0)
1611: {
1612: unsigned int num, den, q, r;
1613:
1614: num = (EAX & 0xffff);
1615: den = (t0 & 0xff);
1616: if (den == 0) {
1617: raise_exception(EXCP00_DIVZ);
1618: }
1619: q = (num / den);
1620: if (q > 0xff)
1621: raise_exception(EXCP00_DIVZ);
1622: q &= 0xff;
1623: r = (num % den) & 0xff;
1624: EAX = (EAX & ~0xffff) | (r << 8) | q;
1625: }
1626:
1627: void helper_idivb_AL(target_ulong t0)
1628: {
1629: int num, den, q, r;
1630:
1631: num = (int16_t)EAX;
1632: den = (int8_t)t0;
1633: if (den == 0) {
1634: raise_exception(EXCP00_DIVZ);
1635: }
1636: q = (num / den);
1637: if (q != (int8_t)q)
1638: raise_exception(EXCP00_DIVZ);
1639: q &= 0xff;
1640: r = (num % den) & 0xff;
1641: EAX = (EAX & ~0xffff) | (r << 8) | q;
1642: }
1643:
1644: void helper_divw_AX(target_ulong t0)
1645: {
1646: unsigned int num, den, q, r;
1647:
1648: num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
1649: den = (t0 & 0xffff);
1650: if (den == 0) {
1651: raise_exception(EXCP00_DIVZ);
1652: }
1653: q = (num / den);
1654: if (q > 0xffff)
1655: raise_exception(EXCP00_DIVZ);
1656: q &= 0xffff;
1657: r = (num % den) & 0xffff;
1658: EAX = (EAX & ~0xffff) | q;
1659: EDX = (EDX & ~0xffff) | r;
1660: }
1661:
1662: void helper_idivw_AX(target_ulong t0)
1663: {
1664: int num, den, q, r;
1665:
1666: num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
1667: den = (int16_t)t0;
1668: if (den == 0) {
1669: raise_exception(EXCP00_DIVZ);
1670: }
1671: q = (num / den);
1672: if (q != (int16_t)q)
1673: raise_exception(EXCP00_DIVZ);
1674: q &= 0xffff;
1675: r = (num % den) & 0xffff;
1676: EAX = (EAX & ~0xffff) | q;
1677: EDX = (EDX & ~0xffff) | r;
1678: }
1679:
1680: void helper_divl_EAX(target_ulong t0)
1681: {
1682: unsigned int den, r;
1683: uint64_t num, q;
1684:
1685: num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
1686: den = t0;
1687: if (den == 0) {
1688: raise_exception(EXCP00_DIVZ);
1689: }
1690: q = (num / den);
1691: r = (num % den);
1692: if (q > 0xffffffff)
1693: raise_exception(EXCP00_DIVZ);
1694: EAX = (uint32_t)q;
1695: EDX = (uint32_t)r;
1696: }
1697:
1698: void helper_idivl_EAX(target_ulong t0)
1699: {
1700: int den, r;
1701: int64_t num, q;
1702:
1703: num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
1704: den = t0;
1705: if (den == 0) {
1706: raise_exception(EXCP00_DIVZ);
1707: }
1708: q = (num / den);
1709: r = (num % den);
1710: if (q != (int32_t)q)
1711: raise_exception(EXCP00_DIVZ);
1712: EAX = (uint32_t)q;
1713: EDX = (uint32_t)r;
1714: }
1715:
1716: /* bcd */
1717:
1718: /* XXX: exception */
1719: void helper_aam(int base)
1720: {
1721: int al, ah;
1722: al = EAX & 0xff;
1723: ah = al / base;
1724: al = al % base;
1725: EAX = (EAX & ~0xffff) | al | (ah << 8);
1726: CC_DST = al;
1727: }
1728:
1729: void helper_aad(int base)
1730: {
1731: int al, ah;
1732: al = EAX & 0xff;
1733: ah = (EAX >> 8) & 0xff;
1734: al = ((ah * base) + al) & 0xff;
1735: EAX = (EAX & ~0xffff) | al;
1736: CC_DST = al;
1737: }
1738:
1739: void helper_aaa(void)
1740: {
1741: int icarry;
1742: int al, ah, af;
1743: int eflags;
1744:
1745: eflags = helper_cc_compute_all(CC_OP);
1746: af = eflags & CC_A;
1747: al = EAX & 0xff;
1748: ah = (EAX >> 8) & 0xff;
1749:
1750: icarry = (al > 0xf9);
1751: if (((al & 0x0f) > 9 ) || af) {
1752: al = (al + 6) & 0x0f;
1753: ah = (ah + 1 + icarry) & 0xff;
1754: eflags |= CC_C | CC_A;
1755: } else {
1756: eflags &= ~(CC_C | CC_A);
1757: al &= 0x0f;
1758: }
1759: EAX = (EAX & ~0xffff) | al | (ah << 8);
1760: CC_SRC = eflags;
1761: }
1762:
1763: void helper_aas(void)
1764: {
1765: int icarry;
1766: int al, ah, af;
1767: int eflags;
1768:
1769: eflags = helper_cc_compute_all(CC_OP);
1770: af = eflags & CC_A;
1771: al = EAX & 0xff;
1772: ah = (EAX >> 8) & 0xff;
1773:
1774: icarry = (al < 6);
1775: if (((al & 0x0f) > 9 ) || af) {
1776: al = (al - 6) & 0x0f;
1777: ah = (ah - 1 - icarry) & 0xff;
1778: eflags |= CC_C | CC_A;
1779: } else {
1780: eflags &= ~(CC_C | CC_A);
1781: al &= 0x0f;
1782: }
1783: EAX = (EAX & ~0xffff) | al | (ah << 8);
1784: CC_SRC = eflags;
1785: }
1786:
1787: void helper_daa(void)
1788: {
1789: int al, af, cf;
1790: int eflags;
1791:
1792: eflags = helper_cc_compute_all(CC_OP);
1793: cf = eflags & CC_C;
1794: af = eflags & CC_A;
1795: al = EAX & 0xff;
1796:
1797: eflags = 0;
1798: if (((al & 0x0f) > 9 ) || af) {
1799: al = (al + 6) & 0xff;
1800: eflags |= CC_A;
1801: }
1802: if ((al > 0x9f) || cf) {
1803: al = (al + 0x60) & 0xff;
1804: eflags |= CC_C;
1805: }
1806: EAX = (EAX & ~0xff) | al;
1807: /* well, speed is not an issue here, so we compute the flags by hand */
1808: eflags |= (al == 0) << 6; /* zf */
1809: eflags |= parity_table[al]; /* pf */
1810: eflags |= (al & 0x80); /* sf */
1811: CC_SRC = eflags;
1812: }
1813:
1814: void helper_das(void)
1815: {
1816: int al, al1, af, cf;
1817: int eflags;
1818:
1819: eflags = helper_cc_compute_all(CC_OP);
1820: cf = eflags & CC_C;
1821: af = eflags & CC_A;
1822: al = EAX & 0xff;
1823:
1824: eflags = 0;
1825: al1 = al;
1826: if (((al & 0x0f) > 9 ) || af) {
1827: eflags |= CC_A;
1828: if (al < 6 || cf)
1829: eflags |= CC_C;
1830: al = (al - 6) & 0xff;
1831: }
1832: if ((al1 > 0x99) || cf) {
1833: al = (al - 0x60) & 0xff;
1834: eflags |= CC_C;
1835: }
1836: EAX = (EAX & ~0xff) | al;
1837: /* well, speed is not an issue here, so we compute the flags by hand */
1838: eflags |= (al == 0) << 6; /* zf */
1839: eflags |= parity_table[al]; /* pf */
1840: eflags |= (al & 0x80); /* sf */
1841: CC_SRC = eflags;
1842: }
1843:
1844: void helper_into(int next_eip_addend)
1845: {
1846: int eflags;
1847: eflags = helper_cc_compute_all(CC_OP);
1848: if (eflags & CC_O) {
1849: raise_interrupt(EXCP04_INTO, 1, 0, next_eip_addend);
1850: }
1851: }
1852:
1853: void helper_cmpxchg8b(target_ulong a0)
1854: {
1855: uint64_t d;
1856: int eflags;
1857:
1858: eflags = helper_cc_compute_all(CC_OP);
1859: d = ldq(a0);
1860: if (d == (((uint64_t)EDX << 32) | (uint32_t)EAX)) {
1861: stq(a0, ((uint64_t)ECX << 32) | (uint32_t)EBX);
1862: eflags |= CC_Z;
1863: } else {
1864: /* always do the store */
1865: stq(a0, d);
1866: EDX = (uint32_t)(d >> 32);
1867: EAX = (uint32_t)d;
1868: eflags &= ~CC_Z;
1869: }
1870: CC_SRC = eflags;
1871: }
1872:
1873: #ifdef TARGET_X86_64
1874: void helper_cmpxchg16b(target_ulong a0)
1875: {
1876: uint64_t d0, d1;
1877: int eflags;
1878:
1879: if ((a0 & 0xf) != 0)
1880: raise_exception(EXCP0D_GPF);
1881: eflags = helper_cc_compute_all(CC_OP);
1882: d0 = ldq(a0);
1883: d1 = ldq(a0 + 8);
1884: if (d0 == EAX && d1 == EDX) {
1885: stq(a0, EBX);
1886: stq(a0 + 8, ECX);
1887: eflags |= CC_Z;
1888: } else {
1889: /* always do the store */
1890: stq(a0, d0);
1891: stq(a0 + 8, d1);
1892: EDX = d1;
1893: EAX = d0;
1894: eflags &= ~CC_Z;
1895: }
1896: CC_SRC = eflags;
1897: }
1898: #endif
1899:
1900: void helper_single_step(void)
1901: {
1902: #ifndef CONFIG_USER_ONLY
1903: check_hw_breakpoints(env, 1);
1904: env->dr[6] |= DR6_BS;
1905: #endif
1906: raise_exception(EXCP01_DB);
1907: }
1908:
1909: void helper_cpuid(void)
1910: {
1911: uint32_t eax, ebx, ecx, edx;
1912:
1913: helper_svm_check_intercept_param(SVM_EXIT_CPUID, 0);
1914:
1915: cpu_x86_cpuid(env, (uint32_t)EAX, (uint32_t)ECX, &eax, &ebx, &ecx, &edx);
1916: EAX = eax;
1917: EBX = ebx;
1918: ECX = ecx;
1919: EDX = edx;
1920: }
1921:
1922: void helper_enter_level(int level, int data32, target_ulong t1)
1923: {
1924: target_ulong ssp;
1925: uint32_t esp_mask, esp, ebp;
1926:
1927: esp_mask = get_sp_mask(env->segs[R_SS].flags);
1928: ssp = env->segs[R_SS].base;
1929: ebp = EBP;
1930: esp = ESP;
1931: if (data32) {
1932: /* 32 bit */
1933: esp -= 4;
1934: while (--level) {
1935: esp -= 4;
1936: ebp -= 4;
1937: stl(ssp + (esp & esp_mask), ldl(ssp + (ebp & esp_mask)));
1938: }
1939: esp -= 4;
1940: stl(ssp + (esp & esp_mask), t1);
1941: } else {
1942: /* 16 bit */
1943: esp -= 2;
1944: while (--level) {
1945: esp -= 2;
1946: ebp -= 2;
1947: stw(ssp + (esp & esp_mask), lduw(ssp + (ebp & esp_mask)));
1948: }
1949: esp -= 2;
1950: stw(ssp + (esp & esp_mask), t1);
1951: }
1952: }
1953:
1954: #ifdef TARGET_X86_64
1955: void helper_enter64_level(int level, int data64, target_ulong t1)
1956: {
1957: target_ulong esp, ebp;
1958: ebp = EBP;
1959: esp = ESP;
1960:
1961: if (data64) {
1962: /* 64 bit */
1963: esp -= 8;
1964: while (--level) {
1965: esp -= 8;
1966: ebp -= 8;
1967: stq(esp, ldq(ebp));
1968: }
1969: esp -= 8;
1970: stq(esp, t1);
1971: } else {
1972: /* 16 bit */
1973: esp -= 2;
1974: while (--level) {
1975: esp -= 2;
1976: ebp -= 2;
1977: stw(esp, lduw(ebp));
1978: }
1979: esp -= 2;
1980: stw(esp, t1);
1981: }
1982: }
1983: #endif
1984:
1985: void helper_lldt(int selector)
1986: {
1987: SegmentCache *dt;
1988: uint32_t e1, e2;
1989: int index, entry_limit;
1990: target_ulong ptr;
1991:
1992: selector &= 0xffff;
1993: if ((selector & 0xfffc) == 0) {
1994: /* XXX: NULL selector case: invalid LDT */
1995: env->ldt.base = 0;
1996: env->ldt.limit = 0;
1997: } else {
1998: if (selector & 0x4)
1999: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2000: dt = &env->gdt;
2001: index = selector & ~7;
2002: #ifdef TARGET_X86_64
2003: if (env->hflags & HF_LMA_MASK)
2004: entry_limit = 15;
2005: else
2006: #endif
2007: entry_limit = 7;
2008: if ((index + entry_limit) > dt->limit)
2009: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2010: ptr = dt->base + index;
2011: e1 = ldl_kernel(ptr);
2012: e2 = ldl_kernel(ptr + 4);
2013: if ((e2 & DESC_S_MASK) || ((e2 >> DESC_TYPE_SHIFT) & 0xf) != 2)
2014: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2015: if (!(e2 & DESC_P_MASK))
2016: raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2017: #ifdef TARGET_X86_64
2018: if (env->hflags & HF_LMA_MASK) {
2019: uint32_t e3;
2020: e3 = ldl_kernel(ptr + 8);
2021: load_seg_cache_raw_dt(&env->ldt, e1, e2);
2022: env->ldt.base |= (target_ulong)e3 << 32;
2023: } else
2024: #endif
2025: {
2026: load_seg_cache_raw_dt(&env->ldt, e1, e2);
2027: }
2028: }
2029: env->ldt.selector = selector;
2030: }
2031:
2032: void helper_ltr(int selector)
2033: {
2034: SegmentCache *dt;
2035: uint32_t e1, e2;
2036: int index, type, entry_limit;
2037: target_ulong ptr;
2038:
2039: selector &= 0xffff;
2040: if ((selector & 0xfffc) == 0) {
2041: /* NULL selector case: invalid TR */
2042: env->tr.base = 0;
2043: env->tr.limit = 0;
2044: env->tr.flags = 0;
2045: } else {
2046: if (selector & 0x4)
2047: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2048: dt = &env->gdt;
2049: index = selector & ~7;
2050: #ifdef TARGET_X86_64
2051: if (env->hflags & HF_LMA_MASK)
2052: entry_limit = 15;
2053: else
2054: #endif
2055: entry_limit = 7;
2056: if ((index + entry_limit) > dt->limit)
2057: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2058: ptr = dt->base + index;
2059: e1 = ldl_kernel(ptr);
2060: e2 = ldl_kernel(ptr + 4);
2061: type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
2062: if ((e2 & DESC_S_MASK) ||
2063: (type != 1 && type != 9))
2064: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2065: if (!(e2 & DESC_P_MASK))
2066: raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2067: #ifdef TARGET_X86_64
2068: if (env->hflags & HF_LMA_MASK) {
2069: uint32_t e3, e4;
2070: e3 = ldl_kernel(ptr + 8);
2071: e4 = ldl_kernel(ptr + 12);
2072: if ((e4 >> DESC_TYPE_SHIFT) & 0xf)
2073: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2074: load_seg_cache_raw_dt(&env->tr, e1, e2);
2075: env->tr.base |= (target_ulong)e3 << 32;
2076: } else
2077: #endif
2078: {
2079: load_seg_cache_raw_dt(&env->tr, e1, e2);
2080: }
2081: e2 |= DESC_TSS_BUSY_MASK;
2082: stl_kernel(ptr + 4, e2);
2083: }
2084: env->tr.selector = selector;
2085: }
2086:
2087: /* only works if protected mode and not VM86. seg_reg must be != R_CS */
2088: void helper_load_seg(int seg_reg, int selector)
2089: {
2090: uint32_t e1, e2;
2091: int cpl, dpl, rpl;
2092: SegmentCache *dt;
2093: int index;
2094: target_ulong ptr;
2095:
2096: selector &= 0xffff;
2097: cpl = env->hflags & HF_CPL_MASK;
2098: if ((selector & 0xfffc) == 0) {
2099: /* null selector case */
2100: if (seg_reg == R_SS
2101: #ifdef TARGET_X86_64
2102: && (!(env->hflags & HF_CS64_MASK) || cpl == 3)
2103: #endif
2104: )
2105: raise_exception_err(EXCP0D_GPF, 0);
2106: cpu_x86_load_seg_cache(env, seg_reg, selector, 0, 0, 0);
2107: } else {
2108:
2109: if (selector & 0x4)
2110: dt = &env->ldt;
2111: else
2112: dt = &env->gdt;
2113: index = selector & ~7;
2114: if ((index + 7) > dt->limit)
2115: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2116: ptr = dt->base + index;
2117: e1 = ldl_kernel(ptr);
2118: e2 = ldl_kernel(ptr + 4);
2119:
2120: if (!(e2 & DESC_S_MASK))
2121: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2122: rpl = selector & 3;
2123: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2124: if (seg_reg == R_SS) {
2125: /* must be writable segment */
2126: if ((e2 & DESC_CS_MASK) || !(e2 & DESC_W_MASK))
2127: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2128: if (rpl != cpl || dpl != cpl)
2129: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2130: } else {
2131: /* must be readable segment */
2132: if ((e2 & (DESC_CS_MASK | DESC_R_MASK)) == DESC_CS_MASK)
2133: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2134:
2135: if (!(e2 & DESC_CS_MASK) || !(e2 & DESC_C_MASK)) {
2136: /* if not conforming code, test rights */
2137: if (dpl < cpl || dpl < rpl)
2138: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2139: }
2140: }
2141:
2142: if (!(e2 & DESC_P_MASK)) {
2143: if (seg_reg == R_SS)
2144: raise_exception_err(EXCP0C_STACK, selector & 0xfffc);
2145: else
2146: raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2147: }
2148:
2149: /* set the access bit if not already set */
2150: if (!(e2 & DESC_A_MASK)) {
2151: e2 |= DESC_A_MASK;
2152: stl_kernel(ptr + 4, e2);
2153: }
2154:
2155: cpu_x86_load_seg_cache(env, seg_reg, selector,
2156: get_seg_base(e1, e2),
2157: get_seg_limit(e1, e2),
2158: e2);
2159: #if 0
2160: qemu_log("load_seg: sel=0x%04x base=0x%08lx limit=0x%08lx flags=%08x\n",
2161: selector, (unsigned long)sc->base, sc->limit, sc->flags);
2162: #endif
2163: }
2164: }
2165:
2166: /* protected mode jump */
2167: void helper_ljmp_protected(int new_cs, target_ulong new_eip,
2168: int next_eip_addend)
2169: {
2170: int gate_cs, type;
2171: uint32_t e1, e2, cpl, dpl, rpl, limit;
2172: target_ulong next_eip;
2173:
2174: if ((new_cs & 0xfffc) == 0)
2175: raise_exception_err(EXCP0D_GPF, 0);
2176: if (load_segment(&e1, &e2, new_cs) != 0)
2177: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2178: cpl = env->hflags & HF_CPL_MASK;
2179: if (e2 & DESC_S_MASK) {
2180: if (!(e2 & DESC_CS_MASK))
2181: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2182: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2183: if (e2 & DESC_C_MASK) {
2184: /* conforming code segment */
2185: if (dpl > cpl)
2186: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2187: } else {
2188: /* non conforming code segment */
2189: rpl = new_cs & 3;
2190: if (rpl > cpl)
2191: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2192: if (dpl != cpl)
2193: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2194: }
2195: if (!(e2 & DESC_P_MASK))
2196: raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2197: limit = get_seg_limit(e1, e2);
2198: if (new_eip > limit &&
2199: !(env->hflags & HF_LMA_MASK) && !(e2 & DESC_L_MASK))
2200: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2201: cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2202: get_seg_base(e1, e2), limit, e2);
2203: EIP = new_eip;
2204: } else {
2205: /* jump to call or task gate */
2206: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2207: rpl = new_cs & 3;
2208: cpl = env->hflags & HF_CPL_MASK;
2209: type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
2210: switch(type) {
2211: case 1: /* 286 TSS */
2212: case 9: /* 386 TSS */
2213: case 5: /* task gate */
2214: if (dpl < cpl || dpl < rpl)
2215: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2216: next_eip = env->eip + next_eip_addend;
2217: switch_tss(new_cs, e1, e2, SWITCH_TSS_JMP, next_eip);
2218: CC_OP = CC_OP_EFLAGS;
2219: break;
2220: case 4: /* 286 call gate */
2221: case 12: /* 386 call gate */
2222: if ((dpl < cpl) || (dpl < rpl))
2223: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2224: if (!(e2 & DESC_P_MASK))
2225: raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2226: gate_cs = e1 >> 16;
2227: new_eip = (e1 & 0xffff);
2228: if (type == 12)
2229: new_eip |= (e2 & 0xffff0000);
2230: if (load_segment(&e1, &e2, gate_cs) != 0)
2231: raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2232: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2233: /* must be code segment */
2234: if (((e2 & (DESC_S_MASK | DESC_CS_MASK)) !=
2235: (DESC_S_MASK | DESC_CS_MASK)))
2236: raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2237: if (((e2 & DESC_C_MASK) && (dpl > cpl)) ||
2238: (!(e2 & DESC_C_MASK) && (dpl != cpl)))
2239: raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2240: if (!(e2 & DESC_P_MASK))
2241: raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2242: limit = get_seg_limit(e1, e2);
2243: if (new_eip > limit)
2244: raise_exception_err(EXCP0D_GPF, 0);
2245: cpu_x86_load_seg_cache(env, R_CS, (gate_cs & 0xfffc) | cpl,
2246: get_seg_base(e1, e2), limit, e2);
2247: EIP = new_eip;
2248: break;
2249: default:
2250: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2251: break;
2252: }
2253: }
2254: }
2255:
2256: /* real mode call */
2257: void helper_lcall_real(int new_cs, target_ulong new_eip1,
2258: int shift, int next_eip)
2259: {
2260: int new_eip;
2261: uint32_t esp, esp_mask;
2262: target_ulong ssp;
2263:
2264: new_eip = new_eip1;
2265: esp = ESP;
2266: esp_mask = get_sp_mask(env->segs[R_SS].flags);
2267: ssp = env->segs[R_SS].base;
2268: if (shift) {
2269: PUSHL(ssp, esp, esp_mask, env->segs[R_CS].selector);
2270: PUSHL(ssp, esp, esp_mask, next_eip);
2271: } else {
2272: PUSHW(ssp, esp, esp_mask, env->segs[R_CS].selector);
2273: PUSHW(ssp, esp, esp_mask, next_eip);
2274: }
2275:
2276: SET_ESP(esp, esp_mask);
2277: env->eip = new_eip;
2278: env->segs[R_CS].selector = new_cs;
2279: env->segs[R_CS].base = (new_cs << 4);
2280: }
2281:
2282: /* protected mode call */
2283: void helper_lcall_protected(int new_cs, target_ulong new_eip,
2284: int shift, int next_eip_addend)
2285: {
2286: int new_stack, i;
2287: uint32_t e1, e2, cpl, dpl, rpl, selector, offset, param_count;
2288: uint32_t ss = 0, ss_e1 = 0, ss_e2 = 0, sp, type, ss_dpl, sp_mask;
2289: uint32_t val, limit, old_sp_mask;
2290: target_ulong ssp, old_ssp, next_eip;
2291:
2292: next_eip = env->eip + next_eip_addend;
2293: LOG_PCALL("lcall %04x:%08x s=%d\n", new_cs, (uint32_t)new_eip, shift);
2294: LOG_PCALL_STATE(env);
2295: if ((new_cs & 0xfffc) == 0)
2296: raise_exception_err(EXCP0D_GPF, 0);
2297: if (load_segment(&e1, &e2, new_cs) != 0)
2298: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2299: cpl = env->hflags & HF_CPL_MASK;
2300: LOG_PCALL("desc=%08x:%08x\n", e1, e2);
2301: if (e2 & DESC_S_MASK) {
2302: if (!(e2 & DESC_CS_MASK))
2303: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2304: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2305: if (e2 & DESC_C_MASK) {
2306: /* conforming code segment */
2307: if (dpl > cpl)
2308: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2309: } else {
2310: /* non conforming code segment */
2311: rpl = new_cs & 3;
2312: if (rpl > cpl)
2313: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2314: if (dpl != cpl)
2315: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2316: }
2317: if (!(e2 & DESC_P_MASK))
2318: raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2319:
2320: #ifdef TARGET_X86_64
2321: /* XXX: check 16/32 bit cases in long mode */
2322: if (shift == 2) {
2323: target_ulong rsp;
2324: /* 64 bit case */
2325: rsp = ESP;
2326: PUSHQ(rsp, env->segs[R_CS].selector);
2327: PUSHQ(rsp, next_eip);
2328: /* from this point, not restartable */
2329: ESP = rsp;
2330: cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2331: get_seg_base(e1, e2),
2332: get_seg_limit(e1, e2), e2);
2333: EIP = new_eip;
2334: } else
2335: #endif
2336: {
2337: sp = ESP;
2338: sp_mask = get_sp_mask(env->segs[R_SS].flags);
2339: ssp = env->segs[R_SS].base;
2340: if (shift) {
2341: PUSHL(ssp, sp, sp_mask, env->segs[R_CS].selector);
2342: PUSHL(ssp, sp, sp_mask, next_eip);
2343: } else {
2344: PUSHW(ssp, sp, sp_mask, env->segs[R_CS].selector);
2345: PUSHW(ssp, sp, sp_mask, next_eip);
2346: }
2347:
2348: limit = get_seg_limit(e1, e2);
2349: if (new_eip > limit)
2350: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2351: /* from this point, not restartable */
2352: SET_ESP(sp, sp_mask);
2353: cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2354: get_seg_base(e1, e2), limit, e2);
2355: EIP = new_eip;
2356: }
2357: } else {
2358: /* check gate type */
2359: type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;
2360: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2361: rpl = new_cs & 3;
2362: switch(type) {
2363: case 1: /* available 286 TSS */
2364: case 9: /* available 386 TSS */
2365: case 5: /* task gate */
2366: if (dpl < cpl || dpl < rpl)
2367: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2368: switch_tss(new_cs, e1, e2, SWITCH_TSS_CALL, next_eip);
2369: CC_OP = CC_OP_EFLAGS;
2370: return;
2371: case 4: /* 286 call gate */
2372: case 12: /* 386 call gate */
2373: break;
2374: default:
2375: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2376: break;
2377: }
2378: shift = type >> 3;
2379:
2380: if (dpl < cpl || dpl < rpl)
2381: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2382: /* check valid bit */
2383: if (!(e2 & DESC_P_MASK))
2384: raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2385: selector = e1 >> 16;
2386: offset = (e2 & 0xffff0000) | (e1 & 0x0000ffff);
2387: param_count = e2 & 0x1f;
2388: if ((selector & 0xfffc) == 0)
2389: raise_exception_err(EXCP0D_GPF, 0);
2390:
2391: if (load_segment(&e1, &e2, selector) != 0)
2392: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2393: if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))
2394: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2395: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2396: if (dpl > cpl)
2397: raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2398: if (!(e2 & DESC_P_MASK))
2399: raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2400:
2401: if (!(e2 & DESC_C_MASK) && dpl < cpl) {
2402: /* to inner privilege */
2403: get_ss_esp_from_tss(&ss, &sp, dpl);
2404: LOG_PCALL("new ss:esp=%04x:%08x param_count=%d ESP=" TARGET_FMT_lx "\n",
2405: ss, sp, param_count, ESP);
2406: if ((ss & 0xfffc) == 0)
2407: raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2408: if ((ss & 3) != dpl)
2409: raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2410: if (load_segment(&ss_e1, &ss_e2, ss) != 0)
2411: raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2412: ss_dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
2413: if (ss_dpl != dpl)
2414: raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2415: if (!(ss_e2 & DESC_S_MASK) ||
2416: (ss_e2 & DESC_CS_MASK) ||
2417: !(ss_e2 & DESC_W_MASK))
2418: raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2419: if (!(ss_e2 & DESC_P_MASK))
2420: raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2421:
2422: // push_size = ((param_count * 2) + 8) << shift;
2423:
2424: old_sp_mask = get_sp_mask(env->segs[R_SS].flags);
2425: old_ssp = env->segs[R_SS].base;
2426:
2427: sp_mask = get_sp_mask(ss_e2);
2428: ssp = get_seg_base(ss_e1, ss_e2);
2429: if (shift) {
2430: PUSHL(ssp, sp, sp_mask, env->segs[R_SS].selector);
2431: PUSHL(ssp, sp, sp_mask, ESP);
2432: for(i = param_count - 1; i >= 0; i--) {
2433: val = ldl_kernel(old_ssp + ((ESP + i * 4) & old_sp_mask));
2434: PUSHL(ssp, sp, sp_mask, val);
2435: }
2436: } else {
2437: PUSHW(ssp, sp, sp_mask, env->segs[R_SS].selector);
2438: PUSHW(ssp, sp, sp_mask, ESP);
2439: for(i = param_count - 1; i >= 0; i--) {
2440: val = lduw_kernel(old_ssp + ((ESP + i * 2) & old_sp_mask));
2441: PUSHW(ssp, sp, sp_mask, val);
2442: }
2443: }
2444: new_stack = 1;
2445: } else {
2446: /* to same privilege */
2447: sp = ESP;
2448: sp_mask = get_sp_mask(env->segs[R_SS].flags);
2449: ssp = env->segs[R_SS].base;
2450: // push_size = (4 << shift);
2451: new_stack = 0;
2452: }
2453:
2454: if (shift) {
2455: PUSHL(ssp, sp, sp_mask, env->segs[R_CS].selector);
2456: PUSHL(ssp, sp, sp_mask, next_eip);
2457: } else {
2458: PUSHW(ssp, sp, sp_mask, env->segs[R_CS].selector);
2459: PUSHW(ssp, sp, sp_mask, next_eip);
2460: }
2461:
2462: /* from this point, not restartable */
2463:
2464: if (new_stack) {
2465: ss = (ss & ~3) | dpl;
2466: cpu_x86_load_seg_cache(env, R_SS, ss,
2467: ssp,
2468: get_seg_limit(ss_e1, ss_e2),
2469: ss_e2);
2470: }
2471:
2472: selector = (selector & ~3) | dpl;
2473: cpu_x86_load_seg_cache(env, R_CS, selector,
2474: get_seg_base(e1, e2),
2475: get_seg_limit(e1, e2),
2476: e2);
2477: cpu_x86_set_cpl(env, dpl);
2478: SET_ESP(sp, sp_mask);
2479: EIP = offset;
2480: }
2481: #ifdef USE_KQEMU
2482: if (kqemu_is_ok(env)) {
2483: env->exception_index = -1;
2484: cpu_loop_exit();
2485: }
2486: #endif
2487: }
2488:
2489: /* real and vm86 mode iret */
2490: void helper_iret_real(int shift)
2491: {
2492: uint32_t sp, new_cs, new_eip, new_eflags, sp_mask;
2493: target_ulong ssp;
2494: int eflags_mask;
2495:
2496: sp_mask = 0xffff; /* XXXX: use SS segment size ? */
2497: sp = ESP;
2498: ssp = env->segs[R_SS].base;
2499: if (shift == 1) {
2500: /* 32 bits */
2501: POPL(ssp, sp, sp_mask, new_eip);
2502: POPL(ssp, sp, sp_mask, new_cs);
2503: new_cs &= 0xffff;
2504: POPL(ssp, sp, sp_mask, new_eflags);
2505: } else {
2506: /* 16 bits */
2507: POPW(ssp, sp, sp_mask, new_eip);
2508: POPW(ssp, sp, sp_mask, new_cs);
2509: POPW(ssp, sp, sp_mask, new_eflags);
2510: }
2511: ESP = (ESP & ~sp_mask) | (sp & sp_mask);
2512: env->segs[R_CS].selector = new_cs;
2513: env->segs[R_CS].base = (new_cs << 4);
2514: env->eip = new_eip;
2515: if (env->eflags & VM_MASK)
2516: eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | RF_MASK | NT_MASK;
2517: else
2518: eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | IOPL_MASK | RF_MASK | NT_MASK;
2519: if (shift == 0)
2520: eflags_mask &= 0xffff;
2521: load_eflags(new_eflags, eflags_mask);
2522: env->hflags2 &= ~HF2_NMI_MASK;
2523: }
2524:
2525: static inline void validate_seg(int seg_reg, int cpl)
2526: {
2527: int dpl;
2528: uint32_t e2;
2529:
2530: /* XXX: on x86_64, we do not want to nullify FS and GS because
2531: they may still contain a valid base. I would be interested to
2532: know how a real x86_64 CPU behaves */
2533: if ((seg_reg == R_FS || seg_reg == R_GS) &&
2534: (env->segs[seg_reg].selector & 0xfffc) == 0)
2535: return;
2536:
2537: e2 = env->segs[seg_reg].flags;
2538: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2539: if (!(e2 & DESC_CS_MASK) || !(e2 & DESC_C_MASK)) {
2540: /* data or non conforming code segment */
2541: if (dpl < cpl) {
2542: cpu_x86_load_seg_cache(env, seg_reg, 0, 0, 0, 0);
2543: }
2544: }
2545: }
2546:
2547: /* protected mode iret */
2548: static inline void helper_ret_protected(int shift, int is_iret, int addend)
2549: {
2550: uint32_t new_cs, new_eflags, new_ss;
2551: uint32_t new_es, new_ds, new_fs, new_gs;
2552: uint32_t e1, e2, ss_e1, ss_e2;
2553: int cpl, dpl, rpl, eflags_mask, iopl;
2554: target_ulong ssp, sp, new_eip, new_esp, sp_mask;
2555:
2556: #ifdef TARGET_X86_64
2557: if (shift == 2)
2558: sp_mask = -1;
2559: else
2560: #endif
2561: sp_mask = get_sp_mask(env->segs[R_SS].flags);
2562: sp = ESP;
2563: ssp = env->segs[R_SS].base;
2564: new_eflags = 0; /* avoid warning */
2565: #ifdef TARGET_X86_64
2566: if (shift == 2) {
2567: POPQ(sp, new_eip);
2568: POPQ(sp, new_cs);
2569: new_cs &= 0xffff;
2570: if (is_iret) {
2571: POPQ(sp, new_eflags);
2572: }
2573: } else
2574: #endif
2575: if (shift == 1) {
2576: /* 32 bits */
2577: POPL(ssp, sp, sp_mask, new_eip);
2578: POPL(ssp, sp, sp_mask, new_cs);
2579: new_cs &= 0xffff;
2580: if (is_iret) {
2581: POPL(ssp, sp, sp_mask, new_eflags);
2582: if (new_eflags & VM_MASK)
2583: goto return_to_vm86;
2584: }
2585: } else {
2586: /* 16 bits */
2587: POPW(ssp, sp, sp_mask, new_eip);
2588: POPW(ssp, sp, sp_mask, new_cs);
2589: if (is_iret)
2590: POPW(ssp, sp, sp_mask, new_eflags);
2591: }
2592: LOG_PCALL("lret new %04x:" TARGET_FMT_lx " s=%d addend=0x%x\n",
2593: new_cs, new_eip, shift, addend);
2594: LOG_PCALL_STATE(env);
2595: if ((new_cs & 0xfffc) == 0)
2596: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2597: if (load_segment(&e1, &e2, new_cs) != 0)
2598: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2599: if (!(e2 & DESC_S_MASK) ||
2600: !(e2 & DESC_CS_MASK))
2601: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2602: cpl = env->hflags & HF_CPL_MASK;
2603: rpl = new_cs & 3;
2604: if (rpl < cpl)
2605: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2606: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2607: if (e2 & DESC_C_MASK) {
2608: if (dpl > rpl)
2609: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2610: } else {
2611: if (dpl != rpl)
2612: raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2613: }
2614: if (!(e2 & DESC_P_MASK))
2615: raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2616:
2617: sp += addend;
2618: if (rpl == cpl && (!(env->hflags & HF_CS64_MASK) ||
2619: ((env->hflags & HF_CS64_MASK) && !is_iret))) {
2620: /* return to same privilege level */
2621: cpu_x86_load_seg_cache(env, R_CS, new_cs,
2622: get_seg_base(e1, e2),
2623: get_seg_limit(e1, e2),
2624: e2);
2625: } else {
2626: /* return to different privilege level */
2627: #ifdef TARGET_X86_64
2628: if (shift == 2) {
2629: POPQ(sp, new_esp);
2630: POPQ(sp, new_ss);
2631: new_ss &= 0xffff;
2632: } else
2633: #endif
2634: if (shift == 1) {
2635: /* 32 bits */
2636: POPL(ssp, sp, sp_mask, new_esp);
2637: POPL(ssp, sp, sp_mask, new_ss);
2638: new_ss &= 0xffff;
2639: } else {
2640: /* 16 bits */
2641: POPW(ssp, sp, sp_mask, new_esp);
2642: POPW(ssp, sp, sp_mask, new_ss);
2643: }
2644: LOG_PCALL("new ss:esp=%04x:" TARGET_FMT_lx "\n",
2645: new_ss, new_esp);
2646: if ((new_ss & 0xfffc) == 0) {
2647: #ifdef TARGET_X86_64
2648: /* NULL ss is allowed in long mode if cpl != 3*/
2649: /* XXX: test CS64 ? */
2650: if ((env->hflags & HF_LMA_MASK) && rpl != 3) {
2651: cpu_x86_load_seg_cache(env, R_SS, new_ss,
2652: 0, 0xffffffff,
2653: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2654: DESC_S_MASK | (rpl << DESC_DPL_SHIFT) |
2655: DESC_W_MASK | DESC_A_MASK);
2656: ss_e2 = DESC_B_MASK; /* XXX: should not be needed ? */
2657: } else
2658: #endif
2659: {
2660: raise_exception_err(EXCP0D_GPF, 0);
2661: }
2662: } else {
2663: if ((new_ss & 3) != rpl)
2664: raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2665: if (load_segment(&ss_e1, &ss_e2, new_ss) != 0)
2666: raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2667: if (!(ss_e2 & DESC_S_MASK) ||
2668: (ss_e2 & DESC_CS_MASK) ||
2669: !(ss_e2 & DESC_W_MASK))
2670: raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2671: dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
2672: if (dpl != rpl)
2673: raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2674: if (!(ss_e2 & DESC_P_MASK))
2675: raise_exception_err(EXCP0B_NOSEG, new_ss & 0xfffc);
2676: cpu_x86_load_seg_cache(env, R_SS, new_ss,
2677: get_seg_base(ss_e1, ss_e2),
2678: get_seg_limit(ss_e1, ss_e2),
2679: ss_e2);
2680: }
2681:
2682: cpu_x86_load_seg_cache(env, R_CS, new_cs,
2683: get_seg_base(e1, e2),
2684: get_seg_limit(e1, e2),
2685: e2);
2686: cpu_x86_set_cpl(env, rpl);
2687: sp = new_esp;
2688: #ifdef TARGET_X86_64
2689: if (env->hflags & HF_CS64_MASK)
2690: sp_mask = -1;
2691: else
2692: #endif
2693: sp_mask = get_sp_mask(ss_e2);
2694:
2695: /* validate data segments */
2696: validate_seg(R_ES, rpl);
2697: validate_seg(R_DS, rpl);
2698: validate_seg(R_FS, rpl);
2699: validate_seg(R_GS, rpl);
2700:
2701: sp += addend;
2702: }
2703: SET_ESP(sp, sp_mask);
2704: env->eip = new_eip;
2705: if (is_iret) {
2706: /* NOTE: 'cpl' is the _old_ CPL */
2707: eflags_mask = TF_MASK | AC_MASK | ID_MASK | RF_MASK | NT_MASK;
2708: if (cpl == 0)
2709: eflags_mask |= IOPL_MASK;
2710: iopl = (env->eflags >> IOPL_SHIFT) & 3;
2711: if (cpl <= iopl)
2712: eflags_mask |= IF_MASK;
2713: if (shift == 0)
2714: eflags_mask &= 0xffff;
2715: load_eflags(new_eflags, eflags_mask);
2716: }
2717: return;
2718:
2719: return_to_vm86:
2720: POPL(ssp, sp, sp_mask, new_esp);
2721: POPL(ssp, sp, sp_mask, new_ss);
2722: POPL(ssp, sp, sp_mask, new_es);
2723: POPL(ssp, sp, sp_mask, new_ds);
2724: POPL(ssp, sp, sp_mask, new_fs);
2725: POPL(ssp, sp, sp_mask, new_gs);
2726:
2727: /* modify processor state */
2728: load_eflags(new_eflags, TF_MASK | AC_MASK | ID_MASK |
2729: IF_MASK | IOPL_MASK | VM_MASK | NT_MASK | VIF_MASK | VIP_MASK);
2730: load_seg_vm(R_CS, new_cs & 0xffff);
2731: cpu_x86_set_cpl(env, 3);
2732: load_seg_vm(R_SS, new_ss & 0xffff);
2733: load_seg_vm(R_ES, new_es & 0xffff);
2734: load_seg_vm(R_DS, new_ds & 0xffff);
2735: load_seg_vm(R_FS, new_fs & 0xffff);
2736: load_seg_vm(R_GS, new_gs & 0xffff);
2737:
2738: env->eip = new_eip & 0xffff;
2739: ESP = new_esp;
2740: }
2741:
2742: void helper_iret_protected(int shift, int next_eip)
2743: {
2744: int tss_selector, type;
2745: uint32_t e1, e2;
2746:
2747: /* specific case for TSS */
2748: if (env->eflags & NT_MASK) {
2749: #ifdef TARGET_X86_64
2750: if (env->hflags & HF_LMA_MASK)
2751: raise_exception_err(EXCP0D_GPF, 0);
2752: #endif
2753: tss_selector = lduw_kernel(env->tr.base + 0);
2754: if (tss_selector & 4)
2755: raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2756: if (load_segment(&e1, &e2, tss_selector) != 0)
2757: raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2758: type = (e2 >> DESC_TYPE_SHIFT) & 0x17;
2759: /* NOTE: we check both segment and busy TSS */
2760: if (type != 3)
2761: raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2762: switch_tss(tss_selector, e1, e2, SWITCH_TSS_IRET, next_eip);
2763: } else {
2764: helper_ret_protected(shift, 1, 0);
2765: }
2766: env->hflags2 &= ~HF2_NMI_MASK;
2767: #ifdef USE_KQEMU
2768: if (kqemu_is_ok(env)) {
2769: CC_OP = CC_OP_EFLAGS;
2770: env->exception_index = -1;
2771: cpu_loop_exit();
2772: }
2773: #endif
2774: }
2775:
2776: void helper_lret_protected(int shift, int addend)
2777: {
2778: helper_ret_protected(shift, 0, addend);
2779: #ifdef USE_KQEMU
2780: if (kqemu_is_ok(env)) {
2781: env->exception_index = -1;
2782: cpu_loop_exit();
2783: }
2784: #endif
2785: }
2786:
2787: void helper_sysenter(void)
2788: {
2789: if (env->sysenter_cs == 0) {
2790: raise_exception_err(EXCP0D_GPF, 0);
2791: }
2792: env->eflags &= ~(VM_MASK | IF_MASK | RF_MASK);
2793: cpu_x86_set_cpl(env, 0);
2794:
2795: #ifdef TARGET_X86_64
2796: if (env->hflags & HF_LMA_MASK) {
2797: cpu_x86_load_seg_cache(env, R_CS, env->sysenter_cs & 0xfffc,
2798: 0, 0xffffffff,
2799: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2800: DESC_S_MASK |
2801: DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
2802: } else
2803: #endif
2804: {
2805: cpu_x86_load_seg_cache(env, R_CS, env->sysenter_cs & 0xfffc,
2806: 0, 0xffffffff,
2807: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2808: DESC_S_MASK |
2809: DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
2810: }
2811: cpu_x86_load_seg_cache(env, R_SS, (env->sysenter_cs + 8) & 0xfffc,
2812: 0, 0xffffffff,
2813: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2814: DESC_S_MASK |
2815: DESC_W_MASK | DESC_A_MASK);
2816: ESP = env->sysenter_esp;
2817: EIP = env->sysenter_eip;
2818: }
2819:
2820: void helper_sysexit(int dflag)
2821: {
2822: int cpl;
2823:
2824: cpl = env->hflags & HF_CPL_MASK;
2825: if (env->sysenter_cs == 0 || cpl != 0) {
2826: raise_exception_err(EXCP0D_GPF, 0);
2827: }
2828: cpu_x86_set_cpl(env, 3);
2829: #ifdef TARGET_X86_64
2830: if (dflag == 2) {
2831: cpu_x86_load_seg_cache(env, R_CS, ((env->sysenter_cs + 32) & 0xfffc) | 3,
2832: 0, 0xffffffff,
2833: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2834: DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2835: DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
2836: cpu_x86_load_seg_cache(env, R_SS, ((env->sysenter_cs + 40) & 0xfffc) | 3,
2837: 0, 0xffffffff,
2838: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2839: DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2840: DESC_W_MASK | DESC_A_MASK);
2841: } else
2842: #endif
2843: {
2844: cpu_x86_load_seg_cache(env, R_CS, ((env->sysenter_cs + 16) & 0xfffc) | 3,
2845: 0, 0xffffffff,
2846: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2847: DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2848: DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
2849: cpu_x86_load_seg_cache(env, R_SS, ((env->sysenter_cs + 24) & 0xfffc) | 3,
2850: 0, 0xffffffff,
2851: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2852: DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2853: DESC_W_MASK | DESC_A_MASK);
2854: }
2855: ESP = ECX;
2856: EIP = EDX;
2857: #ifdef USE_KQEMU
2858: if (kqemu_is_ok(env)) {
2859: env->exception_index = -1;
2860: cpu_loop_exit();
2861: }
2862: #endif
2863: }
2864:
2865: #if defined(CONFIG_USER_ONLY)
2866: target_ulong helper_read_crN(int reg)
2867: {
2868: return 0;
2869: }
2870:
2871: void helper_write_crN(int reg, target_ulong t0)
2872: {
2873: }
2874:
2875: void helper_movl_drN_T0(int reg, target_ulong t0)
2876: {
2877: }
2878: #else
2879: target_ulong helper_read_crN(int reg)
2880: {
2881: target_ulong val;
2882:
2883: helper_svm_check_intercept_param(SVM_EXIT_READ_CR0 + reg, 0);
2884: switch(reg) {
2885: default:
2886: val = env->cr[reg];
2887: break;
2888: case 8:
2889: if (!(env->hflags2 & HF2_VINTR_MASK)) {
2890: val = cpu_get_apic_tpr(env);
2891: } else {
2892: val = env->v_tpr;
2893: }
2894: break;
2895: }
2896: return val;
2897: }
2898:
2899: void helper_write_crN(int reg, target_ulong t0)
2900: {
2901: helper_svm_check_intercept_param(SVM_EXIT_WRITE_CR0 + reg, 0);
2902: switch(reg) {
2903: case 0:
2904: cpu_x86_update_cr0(env, t0);
2905: break;
2906: case 3:
2907: cpu_x86_update_cr3(env, t0);
2908: break;
2909: case 4:
2910: cpu_x86_update_cr4(env, t0);
2911: break;
2912: case 8:
2913: if (!(env->hflags2 & HF2_VINTR_MASK)) {
2914: cpu_set_apic_tpr(env, t0);
2915: }
2916: env->v_tpr = t0 & 0x0f;
2917: break;
2918: default:
2919: env->cr[reg] = t0;
2920: break;
2921: }
2922: }
2923:
2924: void helper_movl_drN_T0(int reg, target_ulong t0)
2925: {
2926: int i;
2927:
2928: if (reg < 4) {
2929: hw_breakpoint_remove(env, reg);
2930: env->dr[reg] = t0;
2931: hw_breakpoint_insert(env, reg);
2932: } else if (reg == 7) {
2933: for (i = 0; i < 4; i++)
2934: hw_breakpoint_remove(env, i);
2935: env->dr[7] = t0;
2936: for (i = 0; i < 4; i++)
2937: hw_breakpoint_insert(env, i);
2938: } else
2939: env->dr[reg] = t0;
2940: }
2941: #endif
2942:
2943: void helper_lmsw(target_ulong t0)
2944: {
2945: /* only 4 lower bits of CR0 are modified. PE cannot be set to zero
2946: if already set to one. */
2947: t0 = (env->cr[0] & ~0xe) | (t0 & 0xf);
2948: helper_write_crN(0, t0);
2949: }
2950:
2951: void helper_clts(void)
2952: {
2953: env->cr[0] &= ~CR0_TS_MASK;
2954: env->hflags &= ~HF_TS_MASK;
2955: }
2956:
2957: void helper_invlpg(target_ulong addr)
2958: {
2959: helper_svm_check_intercept_param(SVM_EXIT_INVLPG, 0);
2960: tlb_flush_page(env, addr);
2961: }
2962:
2963: void helper_rdtsc(void)
2964: {
2965: uint64_t val;
2966:
2967: if ((env->cr[4] & CR4_TSD_MASK) && ((env->hflags & HF_CPL_MASK) != 0)) {
2968: raise_exception(EXCP0D_GPF);
2969: }
2970: helper_svm_check_intercept_param(SVM_EXIT_RDTSC, 0);
2971:
2972: val = cpu_get_tsc(env) + env->tsc_offset;
2973: EAX = (uint32_t)(val);
2974: EDX = (uint32_t)(val >> 32);
2975: }
2976:
2977: void helper_rdpmc(void)
2978: {
2979: if ((env->cr[4] & CR4_PCE_MASK) && ((env->hflags & HF_CPL_MASK) != 0)) {
2980: raise_exception(EXCP0D_GPF);
2981: }
2982: helper_svm_check_intercept_param(SVM_EXIT_RDPMC, 0);
2983:
2984: /* currently unimplemented */
2985: raise_exception_err(EXCP06_ILLOP, 0);
2986: }
2987:
2988: #if defined(CONFIG_USER_ONLY)
2989: void helper_wrmsr(void)
2990: {
2991: }
2992:
2993: void helper_rdmsr(void)
2994: {
2995: }
2996: #else
2997: void helper_wrmsr(void)
2998: {
2999: uint64_t val;
3000:
3001: helper_svm_check_intercept_param(SVM_EXIT_MSR, 1);
3002:
3003: val = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
3004:
3005: switch((uint32_t)ECX) {
3006: case MSR_IA32_SYSENTER_CS:
3007: env->sysenter_cs = val & 0xffff;
3008: break;
3009: case MSR_IA32_SYSENTER_ESP:
3010: env->sysenter_esp = val;
3011: break;
3012: case MSR_IA32_SYSENTER_EIP:
3013: env->sysenter_eip = val;
3014: break;
3015: case MSR_IA32_APICBASE:
3016: cpu_set_apic_base(env, val);
3017: break;
3018: case MSR_EFER:
3019: {
3020: uint64_t update_mask;
3021: update_mask = 0;
3022: if (env->cpuid_ext2_features & CPUID_EXT2_SYSCALL)
3023: update_mask |= MSR_EFER_SCE;
3024: if (env->cpuid_ext2_features & CPUID_EXT2_LM)
3025: update_mask |= MSR_EFER_LME;
3026: if (env->cpuid_ext2_features & CPUID_EXT2_FFXSR)
3027: update_mask |= MSR_EFER_FFXSR;
3028: if (env->cpuid_ext2_features & CPUID_EXT2_NX)
3029: update_mask |= MSR_EFER_NXE;
3030: if (env->cpuid_ext3_features & CPUID_EXT3_SVM)
3031: update_mask |= MSR_EFER_SVME;
3032: if (env->cpuid_ext2_features & CPUID_EXT2_FFXSR)
3033: update_mask |= MSR_EFER_FFXSR;
3034: cpu_load_efer(env, (env->efer & ~update_mask) |
3035: (val & update_mask));
3036: }
3037: break;
3038: case MSR_STAR:
3039: env->star = val;
3040: break;
3041: case MSR_PAT:
3042: env->pat = val;
3043: break;
3044: case MSR_VM_HSAVE_PA:
3045: env->vm_hsave = val;
3046: break;
3047: #ifdef TARGET_X86_64
3048: case MSR_LSTAR:
3049: env->lstar = val;
3050: break;
3051: case MSR_CSTAR:
3052: env->cstar = val;
3053: break;
3054: case MSR_FMASK:
3055: env->fmask = val;
3056: break;
3057: case MSR_FSBASE:
3058: env->segs[R_FS].base = val;
3059: break;
3060: case MSR_GSBASE:
3061: env->segs[R_GS].base = val;
3062: break;
3063: case MSR_KERNELGSBASE:
3064: env->kernelgsbase = val;
3065: break;
3066: #endif
3067: case MSR_MTRRphysBase(0):
3068: case MSR_MTRRphysBase(1):
3069: case MSR_MTRRphysBase(2):
3070: case MSR_MTRRphysBase(3):
3071: case MSR_MTRRphysBase(4):
3072: case MSR_MTRRphysBase(5):
3073: case MSR_MTRRphysBase(6):
3074: case MSR_MTRRphysBase(7):
3075: env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base = val;
3076: break;
3077: case MSR_MTRRphysMask(0):
3078: case MSR_MTRRphysMask(1):
3079: case MSR_MTRRphysMask(2):
3080: case MSR_MTRRphysMask(3):
3081: case MSR_MTRRphysMask(4):
3082: case MSR_MTRRphysMask(5):
3083: case MSR_MTRRphysMask(6):
3084: case MSR_MTRRphysMask(7):
3085: env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask = val;
3086: break;
3087: case MSR_MTRRfix64K_00000:
3088: env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix64K_00000] = val;
3089: break;
3090: case MSR_MTRRfix16K_80000:
3091: case MSR_MTRRfix16K_A0000:
3092: env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1] = val;
3093: break;
3094: case MSR_MTRRfix4K_C0000:
3095: case MSR_MTRRfix4K_C8000:
3096: case MSR_MTRRfix4K_D0000:
3097: case MSR_MTRRfix4K_D8000:
3098: case MSR_MTRRfix4K_E0000:
3099: case MSR_MTRRfix4K_E8000:
3100: case MSR_MTRRfix4K_F0000:
3101: case MSR_MTRRfix4K_F8000:
3102: env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3] = val;
3103: break;
3104: case MSR_MTRRdefType:
3105: env->mtrr_deftype = val;
3106: break;
3107: default:
3108: /* XXX: exception ? */
3109: break;
3110: }
3111: }
3112:
3113: void helper_rdmsr(void)
3114: {
3115: uint64_t val;
3116:
3117: helper_svm_check_intercept_param(SVM_EXIT_MSR, 0);
3118:
3119: switch((uint32_t)ECX) {
3120: case MSR_IA32_SYSENTER_CS:
3121: val = env->sysenter_cs;
3122: break;
3123: case MSR_IA32_SYSENTER_ESP:
3124: val = env->sysenter_esp;
3125: break;
3126: case MSR_IA32_SYSENTER_EIP:
3127: val = env->sysenter_eip;
3128: break;
3129: case MSR_IA32_APICBASE:
3130: val = cpu_get_apic_base(env);
3131: break;
3132: case MSR_EFER:
3133: val = env->efer;
3134: break;
3135: case MSR_STAR:
3136: val = env->star;
3137: break;
3138: case MSR_PAT:
3139: val = env->pat;
3140: break;
3141: case MSR_VM_HSAVE_PA:
3142: val = env->vm_hsave;
3143: break;
3144: case MSR_IA32_PERF_STATUS:
3145: /* tsc_increment_by_tick */
3146: val = 1000ULL;
3147: /* CPU multiplier */
3148: val |= (((uint64_t)4ULL) << 40);
3149: break;
3150: #ifdef TARGET_X86_64
3151: case MSR_LSTAR:
3152: val = env->lstar;
3153: break;
3154: case MSR_CSTAR:
3155: val = env->cstar;
3156: break;
3157: case MSR_FMASK:
3158: val = env->fmask;
3159: break;
3160: case MSR_FSBASE:
3161: val = env->segs[R_FS].base;
3162: break;
3163: case MSR_GSBASE:
3164: val = env->segs[R_GS].base;
3165: break;
3166: case MSR_KERNELGSBASE:
3167: val = env->kernelgsbase;
3168: break;
3169: #endif
3170: #ifdef USE_KQEMU
3171: case MSR_QPI_COMMBASE:
3172: if (env->kqemu_enabled) {
3173: val = kqemu_comm_base;
3174: } else {
3175: val = 0;
3176: }
3177: break;
3178: #endif
3179: case MSR_MTRRphysBase(0):
3180: case MSR_MTRRphysBase(1):
3181: case MSR_MTRRphysBase(2):
3182: case MSR_MTRRphysBase(3):
3183: case MSR_MTRRphysBase(4):
3184: case MSR_MTRRphysBase(5):
3185: case MSR_MTRRphysBase(6):
3186: case MSR_MTRRphysBase(7):
3187: val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base;
3188: break;
3189: case MSR_MTRRphysMask(0):
3190: case MSR_MTRRphysMask(1):
3191: case MSR_MTRRphysMask(2):
3192: case MSR_MTRRphysMask(3):
3193: case MSR_MTRRphysMask(4):
3194: case MSR_MTRRphysMask(5):
3195: case MSR_MTRRphysMask(6):
3196: case MSR_MTRRphysMask(7):
3197: val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask;
3198: break;
3199: case MSR_MTRRfix64K_00000:
3200: val = env->mtrr_fixed[0];
3201: break;
3202: case MSR_MTRRfix16K_80000:
3203: case MSR_MTRRfix16K_A0000:
3204: val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1];
3205: break;
3206: case MSR_MTRRfix4K_C0000:
3207: case MSR_MTRRfix4K_C8000:
3208: case MSR_MTRRfix4K_D0000:
3209: case MSR_MTRRfix4K_D8000:
3210: case MSR_MTRRfix4K_E0000:
3211: case MSR_MTRRfix4K_E8000:
3212: case MSR_MTRRfix4K_F0000:
3213: case MSR_MTRRfix4K_F8000:
3214: val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3];
3215: break;
3216: case MSR_MTRRdefType:
3217: val = env->mtrr_deftype;
3218: break;
3219: case MSR_MTRRcap:
3220: if (env->cpuid_features & CPUID_MTRR)
3221: val = MSR_MTRRcap_VCNT | MSR_MTRRcap_FIXRANGE_SUPPORT | MSR_MTRRcap_WC_SUPPORTED;
3222: else
3223: /* XXX: exception ? */
3224: val = 0;
3225: break;
3226: default:
3227: /* XXX: exception ? */
3228: val = 0;
3229: break;
3230: }
3231: EAX = (uint32_t)(val);
3232: EDX = (uint32_t)(val >> 32);
3233: }
3234: #endif
3235:
3236: target_ulong helper_lsl(target_ulong selector1)
3237: {
3238: unsigned int limit;
3239: uint32_t e1, e2, eflags, selector;
3240: int rpl, dpl, cpl, type;
3241:
3242: selector = selector1 & 0xffff;
3243: eflags = helper_cc_compute_all(CC_OP);
1.1.1.2 ! root 3244: if ((selector & 0xfffc) == 0)
! 3245: goto fail;
1.1 root 3246: if (load_segment(&e1, &e2, selector) != 0)
3247: goto fail;
3248: rpl = selector & 3;
3249: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3250: cpl = env->hflags & HF_CPL_MASK;
3251: if (e2 & DESC_S_MASK) {
3252: if ((e2 & DESC_CS_MASK) && (e2 & DESC_C_MASK)) {
3253: /* conforming */
3254: } else {
3255: if (dpl < cpl || dpl < rpl)
3256: goto fail;
3257: }
3258: } else {
3259: type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
3260: switch(type) {
3261: case 1:
3262: case 2:
3263: case 3:
3264: case 9:
3265: case 11:
3266: break;
3267: default:
3268: goto fail;
3269: }
3270: if (dpl < cpl || dpl < rpl) {
3271: fail:
3272: CC_SRC = eflags & ~CC_Z;
3273: return 0;
3274: }
3275: }
3276: limit = get_seg_limit(e1, e2);
3277: CC_SRC = eflags | CC_Z;
3278: return limit;
3279: }
3280:
3281: target_ulong helper_lar(target_ulong selector1)
3282: {
3283: uint32_t e1, e2, eflags, selector;
3284: int rpl, dpl, cpl, type;
3285:
3286: selector = selector1 & 0xffff;
3287: eflags = helper_cc_compute_all(CC_OP);
3288: if ((selector & 0xfffc) == 0)
3289: goto fail;
3290: if (load_segment(&e1, &e2, selector) != 0)
3291: goto fail;
3292: rpl = selector & 3;
3293: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3294: cpl = env->hflags & HF_CPL_MASK;
3295: if (e2 & DESC_S_MASK) {
3296: if ((e2 & DESC_CS_MASK) && (e2 & DESC_C_MASK)) {
3297: /* conforming */
3298: } else {
3299: if (dpl < cpl || dpl < rpl)
3300: goto fail;
3301: }
3302: } else {
3303: type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
3304: switch(type) {
3305: case 1:
3306: case 2:
3307: case 3:
3308: case 4:
3309: case 5:
3310: case 9:
3311: case 11:
3312: case 12:
3313: break;
3314: default:
3315: goto fail;
3316: }
3317: if (dpl < cpl || dpl < rpl) {
3318: fail:
3319: CC_SRC = eflags & ~CC_Z;
3320: return 0;
3321: }
3322: }
3323: CC_SRC = eflags | CC_Z;
3324: return e2 & 0x00f0ff00;
3325: }
3326:
3327: void helper_verr(target_ulong selector1)
3328: {
3329: uint32_t e1, e2, eflags, selector;
3330: int rpl, dpl, cpl;
3331:
3332: selector = selector1 & 0xffff;
3333: eflags = helper_cc_compute_all(CC_OP);
3334: if ((selector & 0xfffc) == 0)
3335: goto fail;
3336: if (load_segment(&e1, &e2, selector) != 0)
3337: goto fail;
3338: if (!(e2 & DESC_S_MASK))
3339: goto fail;
3340: rpl = selector & 3;
3341: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3342: cpl = env->hflags & HF_CPL_MASK;
3343: if (e2 & DESC_CS_MASK) {
3344: if (!(e2 & DESC_R_MASK))
3345: goto fail;
3346: if (!(e2 & DESC_C_MASK)) {
3347: if (dpl < cpl || dpl < rpl)
3348: goto fail;
3349: }
3350: } else {
3351: if (dpl < cpl || dpl < rpl) {
3352: fail:
3353: CC_SRC = eflags & ~CC_Z;
3354: return;
3355: }
3356: }
3357: CC_SRC = eflags | CC_Z;
3358: }
3359:
3360: void helper_verw(target_ulong selector1)
3361: {
3362: uint32_t e1, e2, eflags, selector;
3363: int rpl, dpl, cpl;
3364:
3365: selector = selector1 & 0xffff;
3366: eflags = helper_cc_compute_all(CC_OP);
3367: if ((selector & 0xfffc) == 0)
3368: goto fail;
3369: if (load_segment(&e1, &e2, selector) != 0)
3370: goto fail;
3371: if (!(e2 & DESC_S_MASK))
3372: goto fail;
3373: rpl = selector & 3;
3374: dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3375: cpl = env->hflags & HF_CPL_MASK;
3376: if (e2 & DESC_CS_MASK) {
3377: goto fail;
3378: } else {
3379: if (dpl < cpl || dpl < rpl)
3380: goto fail;
3381: if (!(e2 & DESC_W_MASK)) {
3382: fail:
3383: CC_SRC = eflags & ~CC_Z;
3384: return;
3385: }
3386: }
3387: CC_SRC = eflags | CC_Z;
3388: }
3389:
3390: /* x87 FPU helpers */
3391:
3392: static void fpu_set_exception(int mask)
3393: {
3394: env->fpus |= mask;
3395: if (env->fpus & (~env->fpuc & FPUC_EM))
3396: env->fpus |= FPUS_SE | FPUS_B;
3397: }
3398:
3399: static inline CPU86_LDouble helper_fdiv(CPU86_LDouble a, CPU86_LDouble b)
3400: {
3401: if (b == 0.0)
3402: fpu_set_exception(FPUS_ZE);
3403: return a / b;
3404: }
3405:
3406: static void fpu_raise_exception(void)
3407: {
3408: if (env->cr[0] & CR0_NE_MASK) {
3409: raise_exception(EXCP10_COPR);
3410: }
3411: #if !defined(CONFIG_USER_ONLY)
3412: else {
3413: cpu_set_ferr(env);
3414: }
3415: #endif
3416: }
3417:
3418: void helper_flds_FT0(uint32_t val)
3419: {
3420: union {
3421: float32 f;
3422: uint32_t i;
3423: } u;
3424: u.i = val;
3425: FT0 = float32_to_floatx(u.f, &env->fp_status);
3426: }
3427:
3428: void helper_fldl_FT0(uint64_t val)
3429: {
3430: union {
3431: float64 f;
3432: uint64_t i;
3433: } u;
3434: u.i = val;
3435: FT0 = float64_to_floatx(u.f, &env->fp_status);
3436: }
3437:
3438: void helper_fildl_FT0(int32_t val)
3439: {
3440: FT0 = int32_to_floatx(val, &env->fp_status);
3441: }
3442:
3443: void helper_flds_ST0(uint32_t val)
3444: {
3445: int new_fpstt;
3446: union {
3447: float32 f;
3448: uint32_t i;
3449: } u;
3450: new_fpstt = (env->fpstt - 1) & 7;
3451: u.i = val;
3452: env->fpregs[new_fpstt].d = float32_to_floatx(u.f, &env->fp_status);
3453: env->fpstt = new_fpstt;
3454: env->fptags[new_fpstt] = 0; /* validate stack entry */
3455: }
3456:
3457: void helper_fldl_ST0(uint64_t val)
3458: {
3459: int new_fpstt;
3460: union {
3461: float64 f;
3462: uint64_t i;
3463: } u;
3464: new_fpstt = (env->fpstt - 1) & 7;
3465: u.i = val;
3466: env->fpregs[new_fpstt].d = float64_to_floatx(u.f, &env->fp_status);
3467: env->fpstt = new_fpstt;
3468: env->fptags[new_fpstt] = 0; /* validate stack entry */
3469: }
3470:
3471: void helper_fildl_ST0(int32_t val)
3472: {
3473: int new_fpstt;
3474: new_fpstt = (env->fpstt - 1) & 7;
3475: env->fpregs[new_fpstt].d = int32_to_floatx(val, &env->fp_status);
3476: env->fpstt = new_fpstt;
3477: env->fptags[new_fpstt] = 0; /* validate stack entry */
3478: }
3479:
3480: void helper_fildll_ST0(int64_t val)
3481: {
3482: int new_fpstt;
3483: new_fpstt = (env->fpstt - 1) & 7;
3484: env->fpregs[new_fpstt].d = int64_to_floatx(val, &env->fp_status);
3485: env->fpstt = new_fpstt;
3486: env->fptags[new_fpstt] = 0; /* validate stack entry */
3487: }
3488:
3489: uint32_t helper_fsts_ST0(void)
3490: {
3491: union {
3492: float32 f;
3493: uint32_t i;
3494: } u;
3495: u.f = floatx_to_float32(ST0, &env->fp_status);
3496: return u.i;
3497: }
3498:
3499: uint64_t helper_fstl_ST0(void)
3500: {
3501: union {
3502: float64 f;
3503: uint64_t i;
3504: } u;
3505: u.f = floatx_to_float64(ST0, &env->fp_status);
3506: return u.i;
3507: }
3508:
3509: int32_t helper_fist_ST0(void)
3510: {
3511: int32_t val;
3512: val = floatx_to_int32(ST0, &env->fp_status);
3513: if (val != (int16_t)val)
3514: val = -32768;
3515: return val;
3516: }
3517:
3518: int32_t helper_fistl_ST0(void)
3519: {
3520: int32_t val;
3521: val = floatx_to_int32(ST0, &env->fp_status);
3522: return val;
3523: }
3524:
3525: int64_t helper_fistll_ST0(void)
3526: {
3527: int64_t val;
3528: val = floatx_to_int64(ST0, &env->fp_status);
3529: return val;
3530: }
3531:
3532: int32_t helper_fistt_ST0(void)
3533: {
3534: int32_t val;
3535: val = floatx_to_int32_round_to_zero(ST0, &env->fp_status);
3536: if (val != (int16_t)val)
3537: val = -32768;
3538: return val;
3539: }
3540:
3541: int32_t helper_fisttl_ST0(void)
3542: {
3543: int32_t val;
3544: val = floatx_to_int32_round_to_zero(ST0, &env->fp_status);
3545: return val;
3546: }
3547:
3548: int64_t helper_fisttll_ST0(void)
3549: {
3550: int64_t val;
3551: val = floatx_to_int64_round_to_zero(ST0, &env->fp_status);
3552: return val;
3553: }
3554:
3555: void helper_fldt_ST0(target_ulong ptr)
3556: {
3557: int new_fpstt;
3558: new_fpstt = (env->fpstt - 1) & 7;
3559: env->fpregs[new_fpstt].d = helper_fldt(ptr);
3560: env->fpstt = new_fpstt;
3561: env->fptags[new_fpstt] = 0; /* validate stack entry */
3562: }
3563:
3564: void helper_fstt_ST0(target_ulong ptr)
3565: {
3566: helper_fstt(ST0, ptr);
3567: }
3568:
3569: void helper_fpush(void)
3570: {
3571: fpush();
3572: }
3573:
3574: void helper_fpop(void)
3575: {
3576: fpop();
3577: }
3578:
3579: void helper_fdecstp(void)
3580: {
3581: env->fpstt = (env->fpstt - 1) & 7;
3582: env->fpus &= (~0x4700);
3583: }
3584:
3585: void helper_fincstp(void)
3586: {
3587: env->fpstt = (env->fpstt + 1) & 7;
3588: env->fpus &= (~0x4700);
3589: }
3590:
3591: /* FPU move */
3592:
3593: void helper_ffree_STN(int st_index)
3594: {
3595: env->fptags[(env->fpstt + st_index) & 7] = 1;
3596: }
3597:
3598: void helper_fmov_ST0_FT0(void)
3599: {
3600: ST0 = FT0;
3601: }
3602:
3603: void helper_fmov_FT0_STN(int st_index)
3604: {
3605: FT0 = ST(st_index);
3606: }
3607:
3608: void helper_fmov_ST0_STN(int st_index)
3609: {
3610: ST0 = ST(st_index);
3611: }
3612:
3613: void helper_fmov_STN_ST0(int st_index)
3614: {
3615: ST(st_index) = ST0;
3616: }
3617:
3618: void helper_fxchg_ST0_STN(int st_index)
3619: {
3620: CPU86_LDouble tmp;
3621: tmp = ST(st_index);
3622: ST(st_index) = ST0;
3623: ST0 = tmp;
3624: }
3625:
3626: /* FPU operations */
3627:
3628: static const int fcom_ccval[4] = {0x0100, 0x4000, 0x0000, 0x4500};
3629:
3630: void helper_fcom_ST0_FT0(void)
3631: {
3632: int ret;
3633:
3634: ret = floatx_compare(ST0, FT0, &env->fp_status);
3635: env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret + 1];
3636: }
3637:
3638: void helper_fucom_ST0_FT0(void)
3639: {
3640: int ret;
3641:
3642: ret = floatx_compare_quiet(ST0, FT0, &env->fp_status);
3643: env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret+ 1];
3644: }
3645:
3646: static const int fcomi_ccval[4] = {CC_C, CC_Z, 0, CC_Z | CC_P | CC_C};
3647:
3648: void helper_fcomi_ST0_FT0(void)
3649: {
3650: int eflags;
3651: int ret;
3652:
3653: ret = floatx_compare(ST0, FT0, &env->fp_status);
3654: eflags = helper_cc_compute_all(CC_OP);
3655: eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3656: CC_SRC = eflags;
3657: }
3658:
3659: void helper_fucomi_ST0_FT0(void)
3660: {
3661: int eflags;
3662: int ret;
3663:
3664: ret = floatx_compare_quiet(ST0, FT0, &env->fp_status);
3665: eflags = helper_cc_compute_all(CC_OP);
3666: eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3667: CC_SRC = eflags;
3668: }
3669:
3670: void helper_fadd_ST0_FT0(void)
3671: {
3672: ST0 += FT0;
3673: }
3674:
3675: void helper_fmul_ST0_FT0(void)
3676: {
3677: ST0 *= FT0;
3678: }
3679:
3680: void helper_fsub_ST0_FT0(void)
3681: {
3682: ST0 -= FT0;
3683: }
3684:
3685: void helper_fsubr_ST0_FT0(void)
3686: {
3687: ST0 = FT0 - ST0;
3688: }
3689:
3690: void helper_fdiv_ST0_FT0(void)
3691: {
3692: ST0 = helper_fdiv(ST0, FT0);
3693: }
3694:
3695: void helper_fdivr_ST0_FT0(void)
3696: {
3697: ST0 = helper_fdiv(FT0, ST0);
3698: }
3699:
3700: /* fp operations between STN and ST0 */
3701:
3702: void helper_fadd_STN_ST0(int st_index)
3703: {
3704: ST(st_index) += ST0;
3705: }
3706:
3707: void helper_fmul_STN_ST0(int st_index)
3708: {
3709: ST(st_index) *= ST0;
3710: }
3711:
3712: void helper_fsub_STN_ST0(int st_index)
3713: {
3714: ST(st_index) -= ST0;
3715: }
3716:
3717: void helper_fsubr_STN_ST0(int st_index)
3718: {
3719: CPU86_LDouble *p;
3720: p = &ST(st_index);
3721: *p = ST0 - *p;
3722: }
3723:
3724: void helper_fdiv_STN_ST0(int st_index)
3725: {
3726: CPU86_LDouble *p;
3727: p = &ST(st_index);
3728: *p = helper_fdiv(*p, ST0);
3729: }
3730:
3731: void helper_fdivr_STN_ST0(int st_index)
3732: {
3733: CPU86_LDouble *p;
3734: p = &ST(st_index);
3735: *p = helper_fdiv(ST0, *p);
3736: }
3737:
3738: /* misc FPU operations */
3739: void helper_fchs_ST0(void)
3740: {
3741: ST0 = floatx_chs(ST0);
3742: }
3743:
3744: void helper_fabs_ST0(void)
3745: {
3746: ST0 = floatx_abs(ST0);
3747: }
3748:
3749: void helper_fld1_ST0(void)
3750: {
3751: ST0 = f15rk[1];
3752: }
3753:
3754: void helper_fldl2t_ST0(void)
3755: {
3756: ST0 = f15rk[6];
3757: }
3758:
3759: void helper_fldl2e_ST0(void)
3760: {
3761: ST0 = f15rk[5];
3762: }
3763:
3764: void helper_fldpi_ST0(void)
3765: {
3766: ST0 = f15rk[2];
3767: }
3768:
3769: void helper_fldlg2_ST0(void)
3770: {
3771: ST0 = f15rk[3];
3772: }
3773:
3774: void helper_fldln2_ST0(void)
3775: {
3776: ST0 = f15rk[4];
3777: }
3778:
3779: void helper_fldz_ST0(void)
3780: {
3781: ST0 = f15rk[0];
3782: }
3783:
3784: void helper_fldz_FT0(void)
3785: {
3786: FT0 = f15rk[0];
3787: }
3788:
3789: uint32_t helper_fnstsw(void)
3790: {
3791: return (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
3792: }
3793:
3794: uint32_t helper_fnstcw(void)
3795: {
3796: return env->fpuc;
3797: }
3798:
3799: static void update_fp_status(void)
3800: {
3801: int rnd_type;
3802:
3803: /* set rounding mode */
3804: switch(env->fpuc & RC_MASK) {
3805: default:
3806: case RC_NEAR:
3807: rnd_type = float_round_nearest_even;
3808: break;
3809: case RC_DOWN:
3810: rnd_type = float_round_down;
3811: break;
3812: case RC_UP:
3813: rnd_type = float_round_up;
3814: break;
3815: case RC_CHOP:
3816: rnd_type = float_round_to_zero;
3817: break;
3818: }
3819: set_float_rounding_mode(rnd_type, &env->fp_status);
3820: #ifdef FLOATX80
3821: switch((env->fpuc >> 8) & 3) {
3822: case 0:
3823: rnd_type = 32;
3824: break;
3825: case 2:
3826: rnd_type = 64;
3827: break;
3828: case 3:
3829: default:
3830: rnd_type = 80;
3831: break;
3832: }
3833: set_floatx80_rounding_precision(rnd_type, &env->fp_status);
3834: #endif
3835: }
3836:
3837: void helper_fldcw(uint32_t val)
3838: {
3839: env->fpuc = val;
3840: update_fp_status();
3841: }
3842:
3843: void helper_fclex(void)
3844: {
3845: env->fpus &= 0x7f00;
3846: }
3847:
3848: void helper_fwait(void)
3849: {
3850: if (env->fpus & FPUS_SE)
3851: fpu_raise_exception();
3852: }
3853:
3854: void helper_fninit(void)
3855: {
3856: env->fpus = 0;
3857: env->fpstt = 0;
3858: env->fpuc = 0x37f;
3859: env->fptags[0] = 1;
3860: env->fptags[1] = 1;
3861: env->fptags[2] = 1;
3862: env->fptags[3] = 1;
3863: env->fptags[4] = 1;
3864: env->fptags[5] = 1;
3865: env->fptags[6] = 1;
3866: env->fptags[7] = 1;
3867: }
3868:
3869: /* BCD ops */
3870:
3871: void helper_fbld_ST0(target_ulong ptr)
3872: {
3873: CPU86_LDouble tmp;
3874: uint64_t val;
3875: unsigned int v;
3876: int i;
3877:
3878: val = 0;
3879: for(i = 8; i >= 0; i--) {
3880: v = ldub(ptr + i);
3881: val = (val * 100) + ((v >> 4) * 10) + (v & 0xf);
3882: }
3883: tmp = val;
3884: if (ldub(ptr + 9) & 0x80)
3885: tmp = -tmp;
3886: fpush();
3887: ST0 = tmp;
3888: }
3889:
3890: void helper_fbst_ST0(target_ulong ptr)
3891: {
3892: int v;
3893: target_ulong mem_ref, mem_end;
3894: int64_t val;
3895:
3896: val = floatx_to_int64(ST0, &env->fp_status);
3897: mem_ref = ptr;
3898: mem_end = mem_ref + 9;
3899: if (val < 0) {
3900: stb(mem_end, 0x80);
3901: val = -val;
3902: } else {
3903: stb(mem_end, 0x00);
3904: }
3905: while (mem_ref < mem_end) {
3906: if (val == 0)
3907: break;
3908: v = val % 100;
3909: val = val / 100;
3910: v = ((v / 10) << 4) | (v % 10);
3911: stb(mem_ref++, v);
3912: }
3913: while (mem_ref < mem_end) {
3914: stb(mem_ref++, 0);
3915: }
3916: }
3917:
3918: void helper_f2xm1(void)
3919: {
3920: ST0 = pow(2.0,ST0) - 1.0;
3921: }
3922:
3923: void helper_fyl2x(void)
3924: {
3925: CPU86_LDouble fptemp;
3926:
3927: fptemp = ST0;
3928: if (fptemp>0.0){
3929: fptemp = log(fptemp)/log(2.0); /* log2(ST) */
3930: ST1 *= fptemp;
3931: fpop();
3932: } else {
3933: env->fpus &= (~0x4700);
3934: env->fpus |= 0x400;
3935: }
3936: }
3937:
3938: void helper_fptan(void)
3939: {
3940: CPU86_LDouble fptemp;
3941:
3942: fptemp = ST0;
3943: if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
3944: env->fpus |= 0x400;
3945: } else {
3946: ST0 = tan(fptemp);
3947: fpush();
3948: ST0 = 1.0;
3949: env->fpus &= (~0x400); /* C2 <-- 0 */
3950: /* the above code is for |arg| < 2**52 only */
3951: }
3952: }
3953:
3954: void helper_fpatan(void)
3955: {
3956: CPU86_LDouble fptemp, fpsrcop;
3957:
3958: fpsrcop = ST1;
3959: fptemp = ST0;
3960: ST1 = atan2(fpsrcop,fptemp);
3961: fpop();
3962: }
3963:
3964: void helper_fxtract(void)
3965: {
3966: CPU86_LDoubleU temp;
3967: unsigned int expdif;
3968:
3969: temp.d = ST0;
3970: expdif = EXPD(temp) - EXPBIAS;
3971: /*DP exponent bias*/
3972: ST0 = expdif;
3973: fpush();
3974: BIASEXPONENT(temp);
3975: ST0 = temp.d;
3976: }
3977:
3978: void helper_fprem1(void)
3979: {
3980: CPU86_LDouble dblq, fpsrcop, fptemp;
3981: CPU86_LDoubleU fpsrcop1, fptemp1;
3982: int expdif;
3983: signed long long int q;
3984:
3985: if (isinf(ST0) || isnan(ST0) || isnan(ST1) || (ST1 == 0.0)) {
3986: ST0 = 0.0 / 0.0; /* NaN */
3987: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
3988: return;
3989: }
3990:
3991: fpsrcop = ST0;
3992: fptemp = ST1;
3993: fpsrcop1.d = fpsrcop;
3994: fptemp1.d = fptemp;
3995: expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
3996:
3997: if (expdif < 0) {
3998: /* optimisation? taken from the AMD docs */
3999: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4000: /* ST0 is unchanged */
4001: return;
4002: }
4003:
4004: if (expdif < 53) {
4005: dblq = fpsrcop / fptemp;
4006: /* round dblq towards nearest integer */
4007: dblq = rint(dblq);
4008: ST0 = fpsrcop - fptemp * dblq;
4009:
4010: /* convert dblq to q by truncating towards zero */
4011: if (dblq < 0.0)
4012: q = (signed long long int)(-dblq);
4013: else
4014: q = (signed long long int)dblq;
4015:
4016: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4017: /* (C0,C3,C1) <-- (q2,q1,q0) */
4018: env->fpus |= (q & 0x4) << (8 - 2); /* (C0) <-- q2 */
4019: env->fpus |= (q & 0x2) << (14 - 1); /* (C3) <-- q1 */
4020: env->fpus |= (q & 0x1) << (9 - 0); /* (C1) <-- q0 */
4021: } else {
4022: env->fpus |= 0x400; /* C2 <-- 1 */
4023: fptemp = pow(2.0, expdif - 50);
4024: fpsrcop = (ST0 / ST1) / fptemp;
4025: /* fpsrcop = integer obtained by chopping */
4026: fpsrcop = (fpsrcop < 0.0) ?
4027: -(floor(fabs(fpsrcop))) : floor(fpsrcop);
4028: ST0 -= (ST1 * fpsrcop * fptemp);
4029: }
4030: }
4031:
4032: void helper_fprem(void)
4033: {
4034: CPU86_LDouble dblq, fpsrcop, fptemp;
4035: CPU86_LDoubleU fpsrcop1, fptemp1;
4036: int expdif;
4037: signed long long int q;
4038:
4039: if (isinf(ST0) || isnan(ST0) || isnan(ST1) || (ST1 == 0.0)) {
4040: ST0 = 0.0 / 0.0; /* NaN */
4041: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4042: return;
4043: }
4044:
4045: fpsrcop = (CPU86_LDouble)ST0;
4046: fptemp = (CPU86_LDouble)ST1;
4047: fpsrcop1.d = fpsrcop;
4048: fptemp1.d = fptemp;
4049: expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
4050:
4051: if (expdif < 0) {
4052: /* optimisation? taken from the AMD docs */
4053: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4054: /* ST0 is unchanged */
4055: return;
4056: }
4057:
4058: if ( expdif < 53 ) {
4059: dblq = fpsrcop/*ST0*/ / fptemp/*ST1*/;
4060: /* round dblq towards zero */
4061: dblq = (dblq < 0.0) ? ceil(dblq) : floor(dblq);
4062: ST0 = fpsrcop/*ST0*/ - fptemp * dblq;
4063:
4064: /* convert dblq to q by truncating towards zero */
4065: if (dblq < 0.0)
4066: q = (signed long long int)(-dblq);
4067: else
4068: q = (signed long long int)dblq;
4069:
4070: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4071: /* (C0,C3,C1) <-- (q2,q1,q0) */
4072: env->fpus |= (q & 0x4) << (8 - 2); /* (C0) <-- q2 */
4073: env->fpus |= (q & 0x2) << (14 - 1); /* (C3) <-- q1 */
4074: env->fpus |= (q & 0x1) << (9 - 0); /* (C1) <-- q0 */
4075: } else {
4076: int N = 32 + (expdif % 32); /* as per AMD docs */
4077: env->fpus |= 0x400; /* C2 <-- 1 */
4078: fptemp = pow(2.0, (double)(expdif - N));
4079: fpsrcop = (ST0 / ST1) / fptemp;
4080: /* fpsrcop = integer obtained by chopping */
4081: fpsrcop = (fpsrcop < 0.0) ?
4082: -(floor(fabs(fpsrcop))) : floor(fpsrcop);
4083: ST0 -= (ST1 * fpsrcop * fptemp);
4084: }
4085: }
4086:
4087: void helper_fyl2xp1(void)
4088: {
4089: CPU86_LDouble fptemp;
4090:
4091: fptemp = ST0;
4092: if ((fptemp+1.0)>0.0) {
4093: fptemp = log(fptemp+1.0) / log(2.0); /* log2(ST+1.0) */
4094: ST1 *= fptemp;
4095: fpop();
4096: } else {
4097: env->fpus &= (~0x4700);
4098: env->fpus |= 0x400;
4099: }
4100: }
4101:
4102: void helper_fsqrt(void)
4103: {
4104: CPU86_LDouble fptemp;
4105:
4106: fptemp = ST0;
4107: if (fptemp<0.0) {
4108: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4109: env->fpus |= 0x400;
4110: }
4111: ST0 = sqrt(fptemp);
4112: }
4113:
4114: void helper_fsincos(void)
4115: {
4116: CPU86_LDouble fptemp;
4117:
4118: fptemp = ST0;
4119: if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4120: env->fpus |= 0x400;
4121: } else {
4122: ST0 = sin(fptemp);
4123: fpush();
4124: ST0 = cos(fptemp);
4125: env->fpus &= (~0x400); /* C2 <-- 0 */
4126: /* the above code is for |arg| < 2**63 only */
4127: }
4128: }
4129:
4130: void helper_frndint(void)
4131: {
4132: ST0 = floatx_round_to_int(ST0, &env->fp_status);
4133: }
4134:
4135: void helper_fscale(void)
4136: {
4137: ST0 = ldexp (ST0, (int)(ST1));
4138: }
4139:
4140: void helper_fsin(void)
4141: {
4142: CPU86_LDouble fptemp;
4143:
4144: fptemp = ST0;
4145: if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4146: env->fpus |= 0x400;
4147: } else {
4148: ST0 = sin(fptemp);
4149: env->fpus &= (~0x400); /* C2 <-- 0 */
4150: /* the above code is for |arg| < 2**53 only */
4151: }
4152: }
4153:
4154: void helper_fcos(void)
4155: {
4156: CPU86_LDouble fptemp;
4157:
4158: fptemp = ST0;
4159: if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4160: env->fpus |= 0x400;
4161: } else {
4162: ST0 = cos(fptemp);
4163: env->fpus &= (~0x400); /* C2 <-- 0 */
4164: /* the above code is for |arg5 < 2**63 only */
4165: }
4166: }
4167:
4168: void helper_fxam_ST0(void)
4169: {
4170: CPU86_LDoubleU temp;
4171: int expdif;
4172:
4173: temp.d = ST0;
4174:
4175: env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4176: if (SIGND(temp))
4177: env->fpus |= 0x200; /* C1 <-- 1 */
4178:
4179: /* XXX: test fptags too */
4180: expdif = EXPD(temp);
4181: if (expdif == MAXEXPD) {
4182: #ifdef USE_X86LDOUBLE
4183: if (MANTD(temp) == 0x8000000000000000ULL)
4184: #else
4185: if (MANTD(temp) == 0)
4186: #endif
4187: env->fpus |= 0x500 /*Infinity*/;
4188: else
4189: env->fpus |= 0x100 /*NaN*/;
4190: } else if (expdif == 0) {
4191: if (MANTD(temp) == 0)
4192: env->fpus |= 0x4000 /*Zero*/;
4193: else
4194: env->fpus |= 0x4400 /*Denormal*/;
4195: } else {
4196: env->fpus |= 0x400;
4197: }
4198: }
4199:
4200: void helper_fstenv(target_ulong ptr, int data32)
4201: {
4202: int fpus, fptag, exp, i;
4203: uint64_t mant;
4204: CPU86_LDoubleU tmp;
4205:
4206: fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
4207: fptag = 0;
4208: for (i=7; i>=0; i--) {
4209: fptag <<= 2;
4210: if (env->fptags[i]) {
4211: fptag |= 3;
4212: } else {
4213: tmp.d = env->fpregs[i].d;
4214: exp = EXPD(tmp);
4215: mant = MANTD(tmp);
4216: if (exp == 0 && mant == 0) {
4217: /* zero */
4218: fptag |= 1;
4219: } else if (exp == 0 || exp == MAXEXPD
4220: #ifdef USE_X86LDOUBLE
4221: || (mant & (1LL << 63)) == 0
4222: #endif
4223: ) {
4224: /* NaNs, infinity, denormal */
4225: fptag |= 2;
4226: }
4227: }
4228: }
4229: if (data32) {
4230: /* 32 bit */
4231: stl(ptr, env->fpuc);
4232: stl(ptr + 4, fpus);
4233: stl(ptr + 8, fptag);
4234: stl(ptr + 12, 0); /* fpip */
4235: stl(ptr + 16, 0); /* fpcs */
4236: stl(ptr + 20, 0); /* fpoo */
4237: stl(ptr + 24, 0); /* fpos */
4238: } else {
4239: /* 16 bit */
4240: stw(ptr, env->fpuc);
4241: stw(ptr + 2, fpus);
4242: stw(ptr + 4, fptag);
4243: stw(ptr + 6, 0);
4244: stw(ptr + 8, 0);
4245: stw(ptr + 10, 0);
4246: stw(ptr + 12, 0);
4247: }
4248: }
4249:
4250: void helper_fldenv(target_ulong ptr, int data32)
4251: {
4252: int i, fpus, fptag;
4253:
4254: if (data32) {
4255: env->fpuc = lduw(ptr);
4256: fpus = lduw(ptr + 4);
4257: fptag = lduw(ptr + 8);
4258: }
4259: else {
4260: env->fpuc = lduw(ptr);
4261: fpus = lduw(ptr + 2);
4262: fptag = lduw(ptr + 4);
4263: }
4264: env->fpstt = (fpus >> 11) & 7;
4265: env->fpus = fpus & ~0x3800;
4266: for(i = 0;i < 8; i++) {
4267: env->fptags[i] = ((fptag & 3) == 3);
4268: fptag >>= 2;
4269: }
4270: }
4271:
4272: void helper_fsave(target_ulong ptr, int data32)
4273: {
4274: CPU86_LDouble tmp;
4275: int i;
4276:
4277: helper_fstenv(ptr, data32);
4278:
4279: ptr += (14 << data32);
4280: for(i = 0;i < 8; i++) {
4281: tmp = ST(i);
4282: helper_fstt(tmp, ptr);
4283: ptr += 10;
4284: }
4285:
4286: /* fninit */
4287: env->fpus = 0;
4288: env->fpstt = 0;
4289: env->fpuc = 0x37f;
4290: env->fptags[0] = 1;
4291: env->fptags[1] = 1;
4292: env->fptags[2] = 1;
4293: env->fptags[3] = 1;
4294: env->fptags[4] = 1;
4295: env->fptags[5] = 1;
4296: env->fptags[6] = 1;
4297: env->fptags[7] = 1;
4298: }
4299:
4300: void helper_frstor(target_ulong ptr, int data32)
4301: {
4302: CPU86_LDouble tmp;
4303: int i;
4304:
4305: helper_fldenv(ptr, data32);
4306: ptr += (14 << data32);
4307:
4308: for(i = 0;i < 8; i++) {
4309: tmp = helper_fldt(ptr);
4310: ST(i) = tmp;
4311: ptr += 10;
4312: }
4313: }
4314:
4315: void helper_fxsave(target_ulong ptr, int data64)
4316: {
4317: int fpus, fptag, i, nb_xmm_regs;
4318: CPU86_LDouble tmp;
4319: target_ulong addr;
4320:
4321: fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
4322: fptag = 0;
4323: for(i = 0; i < 8; i++) {
4324: fptag |= (env->fptags[i] << i);
4325: }
4326: stw(ptr, env->fpuc);
4327: stw(ptr + 2, fpus);
4328: stw(ptr + 4, fptag ^ 0xff);
4329: #ifdef TARGET_X86_64
4330: if (data64) {
4331: stq(ptr + 0x08, 0); /* rip */
4332: stq(ptr + 0x10, 0); /* rdp */
4333: } else
4334: #endif
4335: {
4336: stl(ptr + 0x08, 0); /* eip */
4337: stl(ptr + 0x0c, 0); /* sel */
4338: stl(ptr + 0x10, 0); /* dp */
4339: stl(ptr + 0x14, 0); /* sel */
4340: }
4341:
4342: addr = ptr + 0x20;
4343: for(i = 0;i < 8; i++) {
4344: tmp = ST(i);
4345: helper_fstt(tmp, addr);
4346: addr += 16;
4347: }
4348:
4349: if (env->cr[4] & CR4_OSFXSR_MASK) {
4350: /* XXX: finish it */
4351: stl(ptr + 0x18, env->mxcsr); /* mxcsr */
4352: stl(ptr + 0x1c, 0x0000ffff); /* mxcsr_mask */
4353: if (env->hflags & HF_CS64_MASK)
4354: nb_xmm_regs = 16;
4355: else
4356: nb_xmm_regs = 8;
4357: addr = ptr + 0xa0;
4358: /* Fast FXSAVE leaves out the XMM registers */
4359: if (!(env->efer & MSR_EFER_FFXSR)
4360: || (env->hflags & HF_CPL_MASK)
4361: || !(env->hflags & HF_LMA_MASK)) {
4362: for(i = 0; i < nb_xmm_regs; i++) {
4363: stq(addr, env->xmm_regs[i].XMM_Q(0));
4364: stq(addr + 8, env->xmm_regs[i].XMM_Q(1));
4365: addr += 16;
4366: }
4367: }
4368: }
4369: }
4370:
4371: void helper_fxrstor(target_ulong ptr, int data64)
4372: {
4373: int i, fpus, fptag, nb_xmm_regs;
4374: CPU86_LDouble tmp;
4375: target_ulong addr;
4376:
4377: env->fpuc = lduw(ptr);
4378: fpus = lduw(ptr + 2);
4379: fptag = lduw(ptr + 4);
4380: env->fpstt = (fpus >> 11) & 7;
4381: env->fpus = fpus & ~0x3800;
4382: fptag ^= 0xff;
4383: for(i = 0;i < 8; i++) {
4384: env->fptags[i] = ((fptag >> i) & 1);
4385: }
4386:
4387: addr = ptr + 0x20;
4388: for(i = 0;i < 8; i++) {
4389: tmp = helper_fldt(addr);
4390: ST(i) = tmp;
4391: addr += 16;
4392: }
4393:
4394: if (env->cr[4] & CR4_OSFXSR_MASK) {
4395: /* XXX: finish it */
4396: env->mxcsr = ldl(ptr + 0x18);
4397: //ldl(ptr + 0x1c);
4398: if (env->hflags & HF_CS64_MASK)
4399: nb_xmm_regs = 16;
4400: else
4401: nb_xmm_regs = 8;
4402: addr = ptr + 0xa0;
4403: /* Fast FXRESTORE leaves out the XMM registers */
4404: if (!(env->efer & MSR_EFER_FFXSR)
4405: || (env->hflags & HF_CPL_MASK)
4406: || !(env->hflags & HF_LMA_MASK)) {
4407: for(i = 0; i < nb_xmm_regs; i++) {
4408: env->xmm_regs[i].XMM_Q(0) = ldq(addr);
4409: env->xmm_regs[i].XMM_Q(1) = ldq(addr + 8);
4410: addr += 16;
4411: }
4412: }
4413: }
4414: }
4415:
4416: #ifndef USE_X86LDOUBLE
4417:
4418: void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, CPU86_LDouble f)
4419: {
4420: CPU86_LDoubleU temp;
4421: int e;
4422:
4423: temp.d = f;
4424: /* mantissa */
4425: *pmant = (MANTD(temp) << 11) | (1LL << 63);
4426: /* exponent + sign */
4427: e = EXPD(temp) - EXPBIAS + 16383;
4428: e |= SIGND(temp) >> 16;
4429: *pexp = e;
4430: }
4431:
4432: CPU86_LDouble cpu_set_fp80(uint64_t mant, uint16_t upper)
4433: {
4434: CPU86_LDoubleU temp;
4435: int e;
4436: uint64_t ll;
4437:
4438: /* XXX: handle overflow ? */
4439: e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */
4440: e |= (upper >> 4) & 0x800; /* sign */
4441: ll = (mant >> 11) & ((1LL << 52) - 1);
4442: #ifdef __arm__
4443: temp.l.upper = (e << 20) | (ll >> 32);
4444: temp.l.lower = ll;
4445: #else
4446: temp.ll = ll | ((uint64_t)e << 52);
4447: #endif
4448: return temp.d;
4449: }
4450:
4451: #else
4452:
4453: void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, CPU86_LDouble f)
4454: {
4455: CPU86_LDoubleU temp;
4456:
4457: temp.d = f;
4458: *pmant = temp.l.lower;
4459: *pexp = temp.l.upper;
4460: }
4461:
4462: CPU86_LDouble cpu_set_fp80(uint64_t mant, uint16_t upper)
4463: {
4464: CPU86_LDoubleU temp;
4465:
4466: temp.l.upper = upper;
4467: temp.l.lower = mant;
4468: return temp.d;
4469: }
4470: #endif
4471:
4472: #ifdef TARGET_X86_64
4473:
4474: //#define DEBUG_MULDIV
4475:
4476: static void add128(uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)
4477: {
4478: *plow += a;
4479: /* carry test */
4480: if (*plow < a)
4481: (*phigh)++;
4482: *phigh += b;
4483: }
4484:
4485: static void neg128(uint64_t *plow, uint64_t *phigh)
4486: {
4487: *plow = ~ *plow;
4488: *phigh = ~ *phigh;
4489: add128(plow, phigh, 1, 0);
4490: }
4491:
4492: /* return TRUE if overflow */
4493: static int div64(uint64_t *plow, uint64_t *phigh, uint64_t b)
4494: {
4495: uint64_t q, r, a1, a0;
4496: int i, qb, ab;
4497:
4498: a0 = *plow;
4499: a1 = *phigh;
4500: if (a1 == 0) {
4501: q = a0 / b;
4502: r = a0 % b;
4503: *plow = q;
4504: *phigh = r;
4505: } else {
4506: if (a1 >= b)
4507: return 1;
4508: /* XXX: use a better algorithm */
4509: for(i = 0; i < 64; i++) {
4510: ab = a1 >> 63;
4511: a1 = (a1 << 1) | (a0 >> 63);
4512: if (ab || a1 >= b) {
4513: a1 -= b;
4514: qb = 1;
4515: } else {
4516: qb = 0;
4517: }
4518: a0 = (a0 << 1) | qb;
4519: }
4520: #if defined(DEBUG_MULDIV)
4521: printf("div: 0x%016" PRIx64 "%016" PRIx64 " / 0x%016" PRIx64 ": q=0x%016" PRIx64 " r=0x%016" PRIx64 "\n",
4522: *phigh, *plow, b, a0, a1);
4523: #endif
4524: *plow = a0;
4525: *phigh = a1;
4526: }
4527: return 0;
4528: }
4529:
4530: /* return TRUE if overflow */
4531: static int idiv64(uint64_t *plow, uint64_t *phigh, int64_t b)
4532: {
4533: int sa, sb;
4534: sa = ((int64_t)*phigh < 0);
4535: if (sa)
4536: neg128(plow, phigh);
4537: sb = (b < 0);
4538: if (sb)
4539: b = -b;
4540: if (div64(plow, phigh, b) != 0)
4541: return 1;
4542: if (sa ^ sb) {
4543: if (*plow > (1ULL << 63))
4544: return 1;
4545: *plow = - *plow;
4546: } else {
4547: if (*plow >= (1ULL << 63))
4548: return 1;
4549: }
4550: if (sa)
4551: *phigh = - *phigh;
4552: return 0;
4553: }
4554:
4555: void helper_mulq_EAX_T0(target_ulong t0)
4556: {
4557: uint64_t r0, r1;
4558:
4559: mulu64(&r0, &r1, EAX, t0);
4560: EAX = r0;
4561: EDX = r1;
4562: CC_DST = r0;
4563: CC_SRC = r1;
4564: }
4565:
4566: void helper_imulq_EAX_T0(target_ulong t0)
4567: {
4568: uint64_t r0, r1;
4569:
4570: muls64(&r0, &r1, EAX, t0);
4571: EAX = r0;
4572: EDX = r1;
4573: CC_DST = r0;
4574: CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
4575: }
4576:
4577: target_ulong helper_imulq_T0_T1(target_ulong t0, target_ulong t1)
4578: {
4579: uint64_t r0, r1;
4580:
4581: muls64(&r0, &r1, t0, t1);
4582: CC_DST = r0;
4583: CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
4584: return r0;
4585: }
4586:
4587: void helper_divq_EAX(target_ulong t0)
4588: {
4589: uint64_t r0, r1;
4590: if (t0 == 0) {
4591: raise_exception(EXCP00_DIVZ);
4592: }
4593: r0 = EAX;
4594: r1 = EDX;
4595: if (div64(&r0, &r1, t0))
4596: raise_exception(EXCP00_DIVZ);
4597: EAX = r0;
4598: EDX = r1;
4599: }
4600:
4601: void helper_idivq_EAX(target_ulong t0)
4602: {
4603: uint64_t r0, r1;
4604: if (t0 == 0) {
4605: raise_exception(EXCP00_DIVZ);
4606: }
4607: r0 = EAX;
4608: r1 = EDX;
4609: if (idiv64(&r0, &r1, t0))
4610: raise_exception(EXCP00_DIVZ);
4611: EAX = r0;
4612: EDX = r1;
4613: }
4614: #endif
4615:
4616: static void do_hlt(void)
4617: {
4618: env->hflags &= ~HF_INHIBIT_IRQ_MASK; /* needed if sti is just before */
4619: env->halted = 1;
4620: env->exception_index = EXCP_HLT;
4621: cpu_loop_exit();
4622: }
4623:
4624: void helper_hlt(int next_eip_addend)
4625: {
4626: helper_svm_check_intercept_param(SVM_EXIT_HLT, 0);
4627: EIP += next_eip_addend;
4628:
4629: do_hlt();
4630: }
4631:
4632: void helper_monitor(target_ulong ptr)
4633: {
4634: if ((uint32_t)ECX != 0)
4635: raise_exception(EXCP0D_GPF);
4636: /* XXX: store address ? */
4637: helper_svm_check_intercept_param(SVM_EXIT_MONITOR, 0);
4638: }
4639:
4640: void helper_mwait(int next_eip_addend)
4641: {
4642: if ((uint32_t)ECX != 0)
4643: raise_exception(EXCP0D_GPF);
4644: helper_svm_check_intercept_param(SVM_EXIT_MWAIT, 0);
4645: EIP += next_eip_addend;
4646:
4647: /* XXX: not complete but not completely erroneous */
4648: if (env->cpu_index != 0 || env->next_cpu != NULL) {
4649: /* more than one CPU: do not sleep because another CPU may
4650: wake this one */
4651: } else {
4652: do_hlt();
4653: }
4654: }
4655:
4656: void helper_debug(void)
4657: {
4658: env->exception_index = EXCP_DEBUG;
4659: cpu_loop_exit();
4660: }
4661:
4662: void helper_raise_interrupt(int intno, int next_eip_addend)
4663: {
4664: raise_interrupt(intno, 1, 0, next_eip_addend);
4665: }
4666:
4667: void helper_raise_exception(int exception_index)
4668: {
4669: raise_exception(exception_index);
4670: }
4671:
4672: void helper_cli(void)
4673: {
4674: env->eflags &= ~IF_MASK;
4675: }
4676:
4677: void helper_sti(void)
4678: {
4679: env->eflags |= IF_MASK;
4680: }
4681:
4682: #if 0
4683: /* vm86plus instructions */
4684: void helper_cli_vm(void)
4685: {
4686: env->eflags &= ~VIF_MASK;
4687: }
4688:
4689: void helper_sti_vm(void)
4690: {
4691: env->eflags |= VIF_MASK;
4692: if (env->eflags & VIP_MASK) {
4693: raise_exception(EXCP0D_GPF);
4694: }
4695: }
4696: #endif
4697:
4698: void helper_set_inhibit_irq(void)
4699: {
4700: env->hflags |= HF_INHIBIT_IRQ_MASK;
4701: }
4702:
4703: void helper_reset_inhibit_irq(void)
4704: {
4705: env->hflags &= ~HF_INHIBIT_IRQ_MASK;
4706: }
4707:
4708: void helper_boundw(target_ulong a0, int v)
4709: {
4710: int low, high;
4711: low = ldsw(a0);
4712: high = ldsw(a0 + 2);
4713: v = (int16_t)v;
4714: if (v < low || v > high) {
4715: raise_exception(EXCP05_BOUND);
4716: }
4717: }
4718:
4719: void helper_boundl(target_ulong a0, int v)
4720: {
4721: int low, high;
4722: low = ldl(a0);
4723: high = ldl(a0 + 4);
4724: if (v < low || v > high) {
4725: raise_exception(EXCP05_BOUND);
4726: }
4727: }
4728:
4729: static float approx_rsqrt(float a)
4730: {
4731: return 1.0 / sqrt(a);
4732: }
4733:
4734: static float approx_rcp(float a)
4735: {
4736: return 1.0 / a;
4737: }
4738:
4739: #if !defined(CONFIG_USER_ONLY)
4740:
4741: #define MMUSUFFIX _mmu
4742:
4743: #define SHIFT 0
4744: #include "softmmu_template.h"
4745:
4746: #define SHIFT 1
4747: #include "softmmu_template.h"
4748:
4749: #define SHIFT 2
4750: #include "softmmu_template.h"
4751:
4752: #define SHIFT 3
4753: #include "softmmu_template.h"
4754:
4755: #endif
4756:
4757: #if !defined(CONFIG_USER_ONLY)
4758: /* try to fill the TLB and return an exception if error. If retaddr is
4759: NULL, it means that the function was called in C code (i.e. not
4760: from generated code or from helper.c) */
4761: /* XXX: fix it to restore all registers */
4762: void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
4763: {
4764: TranslationBlock *tb;
4765: int ret;
4766: unsigned long pc;
4767: CPUX86State *saved_env;
4768:
4769: /* XXX: hack to restore env in all cases, even if not called from
4770: generated code */
4771: saved_env = env;
4772: env = cpu_single_env;
4773:
4774: ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
4775: if (ret) {
4776: if (retaddr) {
4777: /* now we have a real cpu fault */
4778: pc = (unsigned long)retaddr;
4779: tb = tb_find_pc(pc);
4780: if (tb) {
4781: /* the PC is inside the translated code. It means that we have
4782: a virtual CPU fault */
4783: cpu_restore_state(tb, env, pc, NULL);
4784: }
4785: }
4786: raise_exception_err(env->exception_index, env->error_code);
4787: }
4788: env = saved_env;
4789: }
4790: #endif
4791:
4792: /* Secure Virtual Machine helpers */
4793:
4794: #if defined(CONFIG_USER_ONLY)
4795:
4796: void helper_vmrun(int aflag, int next_eip_addend)
4797: {
4798: }
4799: void helper_vmmcall(void)
4800: {
4801: }
4802: void helper_vmload(int aflag)
4803: {
4804: }
4805: void helper_vmsave(int aflag)
4806: {
4807: }
4808: void helper_stgi(void)
4809: {
4810: }
4811: void helper_clgi(void)
4812: {
4813: }
4814: void helper_skinit(void)
4815: {
4816: }
4817: void helper_invlpga(int aflag)
4818: {
4819: }
4820: void helper_vmexit(uint32_t exit_code, uint64_t exit_info_1)
4821: {
4822: }
4823: void helper_svm_check_intercept_param(uint32_t type, uint64_t param)
4824: {
4825: }
4826:
4827: void helper_svm_check_io(uint32_t port, uint32_t param,
4828: uint32_t next_eip_addend)
4829: {
4830: }
4831: #else
4832:
4833: static inline void svm_save_seg(target_phys_addr_t addr,
4834: const SegmentCache *sc)
4835: {
4836: stw_phys(addr + offsetof(struct vmcb_seg, selector),
4837: sc->selector);
4838: stq_phys(addr + offsetof(struct vmcb_seg, base),
4839: sc->base);
4840: stl_phys(addr + offsetof(struct vmcb_seg, limit),
4841: sc->limit);
4842: stw_phys(addr + offsetof(struct vmcb_seg, attrib),
4843: ((sc->flags >> 8) & 0xff) | ((sc->flags >> 12) & 0x0f00));
4844: }
4845:
4846: static inline void svm_load_seg(target_phys_addr_t addr, SegmentCache *sc)
4847: {
4848: unsigned int flags;
4849:
4850: sc->selector = lduw_phys(addr + offsetof(struct vmcb_seg, selector));
4851: sc->base = ldq_phys(addr + offsetof(struct vmcb_seg, base));
4852: sc->limit = ldl_phys(addr + offsetof(struct vmcb_seg, limit));
4853: flags = lduw_phys(addr + offsetof(struct vmcb_seg, attrib));
4854: sc->flags = ((flags & 0xff) << 8) | ((flags & 0x0f00) << 12);
4855: }
4856:
4857: static inline void svm_load_seg_cache(target_phys_addr_t addr,
4858: CPUState *env, int seg_reg)
4859: {
4860: SegmentCache sc1, *sc = &sc1;
4861: svm_load_seg(addr, sc);
4862: cpu_x86_load_seg_cache(env, seg_reg, sc->selector,
4863: sc->base, sc->limit, sc->flags);
4864: }
4865:
4866: void helper_vmrun(int aflag, int next_eip_addend)
4867: {
4868: target_ulong addr;
4869: uint32_t event_inj;
4870: uint32_t int_ctl;
4871:
4872: helper_svm_check_intercept_param(SVM_EXIT_VMRUN, 0);
4873:
4874: if (aflag == 2)
4875: addr = EAX;
4876: else
4877: addr = (uint32_t)EAX;
4878:
4879: qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmrun! " TARGET_FMT_lx "\n", addr);
4880:
4881: env->vm_vmcb = addr;
4882:
4883: /* save the current CPU state in the hsave page */
4884: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.base), env->gdt.base);
4885: stl_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.limit), env->gdt.limit);
4886:
4887: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.base), env->idt.base);
4888: stl_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.limit), env->idt.limit);
4889:
4890: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr0), env->cr[0]);
4891: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr2), env->cr[2]);
4892: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr3), env->cr[3]);
4893: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr4), env->cr[4]);
4894: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr6), env->dr[6]);
4895: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr7), env->dr[7]);
4896:
4897: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.efer), env->efer);
4898: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rflags), compute_eflags());
4899:
4900: svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.es),
4901: &env->segs[R_ES]);
4902: svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.cs),
4903: &env->segs[R_CS]);
4904: svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.ss),
4905: &env->segs[R_SS]);
4906: svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.ds),
4907: &env->segs[R_DS]);
4908:
4909: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rip),
4910: EIP + next_eip_addend);
4911: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rsp), ESP);
4912: stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rax), EAX);
4913:
4914: /* load the interception bitmaps so we do not need to access the
4915: vmcb in svm mode */
4916: env->intercept = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept));
4917: env->intercept_cr_read = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_cr_read));
4918: env->intercept_cr_write = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_cr_write));
4919: env->intercept_dr_read = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_dr_read));
4920: env->intercept_dr_write = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_dr_write));
4921: env->intercept_exceptions = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_exceptions));
4922:
4923: /* enable intercepts */
4924: env->hflags |= HF_SVMI_MASK;
4925:
4926: env->tsc_offset = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.tsc_offset));
4927:
4928: env->gdt.base = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.base));
4929: env->gdt.limit = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.limit));
4930:
4931: env->idt.base = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.base));
4932: env->idt.limit = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.limit));
4933:
4934: /* clear exit_info_2 so we behave like the real hardware */
4935: stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2), 0);
4936:
4937: cpu_x86_update_cr0(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr0)));
4938: cpu_x86_update_cr4(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr4)));
4939: cpu_x86_update_cr3(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr3)));
4940: env->cr[2] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr2));
4941: int_ctl = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl));
4942: env->hflags2 &= ~(HF2_HIF_MASK | HF2_VINTR_MASK);
4943: if (int_ctl & V_INTR_MASKING_MASK) {
4944: env->v_tpr = int_ctl & V_TPR_MASK;
4945: env->hflags2 |= HF2_VINTR_MASK;
4946: if (env->eflags & IF_MASK)
4947: env->hflags2 |= HF2_HIF_MASK;
4948: }
4949:
4950: cpu_load_efer(env,
4951: ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.efer)));
4952: env->eflags = 0;
4953: load_eflags(ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rflags)),
4954: ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
4955: CC_OP = CC_OP_EFLAGS;
4956:
4957: svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.es),
4958: env, R_ES);
4959: svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.cs),
4960: env, R_CS);
4961: svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.ss),
4962: env, R_SS);
4963: svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.ds),
4964: env, R_DS);
4965:
4966: EIP = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rip));
4967: env->eip = EIP;
4968: ESP = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rsp));
4969: EAX = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rax));
4970: env->dr[7] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr7));
4971: env->dr[6] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr6));
4972: cpu_x86_set_cpl(env, ldub_phys(env->vm_vmcb + offsetof(struct vmcb, save.cpl)));
4973:
4974: /* FIXME: guest state consistency checks */
4975:
4976: switch(ldub_phys(env->vm_vmcb + offsetof(struct vmcb, control.tlb_ctl))) {
4977: case TLB_CONTROL_DO_NOTHING:
4978: break;
4979: case TLB_CONTROL_FLUSH_ALL_ASID:
4980: /* FIXME: this is not 100% correct but should work for now */
4981: tlb_flush(env, 1);
4982: break;
4983: }
4984:
4985: env->hflags2 |= HF2_GIF_MASK;
4986:
4987: if (int_ctl & V_IRQ_MASK) {
4988: env->interrupt_request |= CPU_INTERRUPT_VIRQ;
4989: }
4990:
4991: /* maybe we need to inject an event */
4992: event_inj = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj));
4993: if (event_inj & SVM_EVTINJ_VALID) {
4994: uint8_t vector = event_inj & SVM_EVTINJ_VEC_MASK;
4995: uint16_t valid_err = event_inj & SVM_EVTINJ_VALID_ERR;
4996: uint32_t event_inj_err = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj_err));
4997: stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj), event_inj & ~SVM_EVTINJ_VALID);
4998:
4999: qemu_log_mask(CPU_LOG_TB_IN_ASM, "Injecting(%#hx): ", valid_err);
5000: /* FIXME: need to implement valid_err */
5001: switch (event_inj & SVM_EVTINJ_TYPE_MASK) {
5002: case SVM_EVTINJ_TYPE_INTR:
5003: env->exception_index = vector;
5004: env->error_code = event_inj_err;
5005: env->exception_is_int = 0;
5006: env->exception_next_eip = -1;
5007: qemu_log_mask(CPU_LOG_TB_IN_ASM, "INTR");
5008: /* XXX: is it always correct ? */
5009: do_interrupt(vector, 0, 0, 0, 1);
5010: break;
5011: case SVM_EVTINJ_TYPE_NMI:
5012: env->exception_index = EXCP02_NMI;
5013: env->error_code = event_inj_err;
5014: env->exception_is_int = 0;
5015: env->exception_next_eip = EIP;
5016: qemu_log_mask(CPU_LOG_TB_IN_ASM, "NMI");
5017: cpu_loop_exit();
5018: break;
5019: case SVM_EVTINJ_TYPE_EXEPT:
5020: env->exception_index = vector;
5021: env->error_code = event_inj_err;
5022: env->exception_is_int = 0;
5023: env->exception_next_eip = -1;
5024: qemu_log_mask(CPU_LOG_TB_IN_ASM, "EXEPT");
5025: cpu_loop_exit();
5026: break;
5027: case SVM_EVTINJ_TYPE_SOFT:
5028: env->exception_index = vector;
5029: env->error_code = event_inj_err;
5030: env->exception_is_int = 1;
5031: env->exception_next_eip = EIP;
5032: qemu_log_mask(CPU_LOG_TB_IN_ASM, "SOFT");
5033: cpu_loop_exit();
5034: break;
5035: }
5036: qemu_log_mask(CPU_LOG_TB_IN_ASM, " %#x %#x\n", env->exception_index, env->error_code);
5037: }
5038: }
5039:
5040: void helper_vmmcall(void)
5041: {
5042: helper_svm_check_intercept_param(SVM_EXIT_VMMCALL, 0);
5043: raise_exception(EXCP06_ILLOP);
5044: }
5045:
5046: void helper_vmload(int aflag)
5047: {
5048: target_ulong addr;
5049: helper_svm_check_intercept_param(SVM_EXIT_VMLOAD, 0);
5050:
5051: if (aflag == 2)
5052: addr = EAX;
5053: else
5054: addr = (uint32_t)EAX;
5055:
5056: qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmload! " TARGET_FMT_lx "\nFS: %016" PRIx64 " | " TARGET_FMT_lx "\n",
5057: addr, ldq_phys(addr + offsetof(struct vmcb, save.fs.base)),
5058: env->segs[R_FS].base);
5059:
5060: svm_load_seg_cache(addr + offsetof(struct vmcb, save.fs),
5061: env, R_FS);
5062: svm_load_seg_cache(addr + offsetof(struct vmcb, save.gs),
5063: env, R_GS);
5064: svm_load_seg(addr + offsetof(struct vmcb, save.tr),
5065: &env->tr);
5066: svm_load_seg(addr + offsetof(struct vmcb, save.ldtr),
5067: &env->ldt);
5068:
5069: #ifdef TARGET_X86_64
5070: env->kernelgsbase = ldq_phys(addr + offsetof(struct vmcb, save.kernel_gs_base));
5071: env->lstar = ldq_phys(addr + offsetof(struct vmcb, save.lstar));
5072: env->cstar = ldq_phys(addr + offsetof(struct vmcb, save.cstar));
5073: env->fmask = ldq_phys(addr + offsetof(struct vmcb, save.sfmask));
5074: #endif
5075: env->star = ldq_phys(addr + offsetof(struct vmcb, save.star));
5076: env->sysenter_cs = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_cs));
5077: env->sysenter_esp = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_esp));
5078: env->sysenter_eip = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_eip));
5079: }
5080:
5081: void helper_vmsave(int aflag)
5082: {
5083: target_ulong addr;
5084: helper_svm_check_intercept_param(SVM_EXIT_VMSAVE, 0);
5085:
5086: if (aflag == 2)
5087: addr = EAX;
5088: else
5089: addr = (uint32_t)EAX;
5090:
5091: qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmsave! " TARGET_FMT_lx "\nFS: %016" PRIx64 " | " TARGET_FMT_lx "\n",
5092: addr, ldq_phys(addr + offsetof(struct vmcb, save.fs.base)),
5093: env->segs[R_FS].base);
5094:
5095: svm_save_seg(addr + offsetof(struct vmcb, save.fs),
5096: &env->segs[R_FS]);
5097: svm_save_seg(addr + offsetof(struct vmcb, save.gs),
5098: &env->segs[R_GS]);
5099: svm_save_seg(addr + offsetof(struct vmcb, save.tr),
5100: &env->tr);
5101: svm_save_seg(addr + offsetof(struct vmcb, save.ldtr),
5102: &env->ldt);
5103:
5104: #ifdef TARGET_X86_64
5105: stq_phys(addr + offsetof(struct vmcb, save.kernel_gs_base), env->kernelgsbase);
5106: stq_phys(addr + offsetof(struct vmcb, save.lstar), env->lstar);
5107: stq_phys(addr + offsetof(struct vmcb, save.cstar), env->cstar);
5108: stq_phys(addr + offsetof(struct vmcb, save.sfmask), env->fmask);
5109: #endif
5110: stq_phys(addr + offsetof(struct vmcb, save.star), env->star);
5111: stq_phys(addr + offsetof(struct vmcb, save.sysenter_cs), env->sysenter_cs);
5112: stq_phys(addr + offsetof(struct vmcb, save.sysenter_esp), env->sysenter_esp);
5113: stq_phys(addr + offsetof(struct vmcb, save.sysenter_eip), env->sysenter_eip);
5114: }
5115:
5116: void helper_stgi(void)
5117: {
5118: helper_svm_check_intercept_param(SVM_EXIT_STGI, 0);
5119: env->hflags2 |= HF2_GIF_MASK;
5120: }
5121:
5122: void helper_clgi(void)
5123: {
5124: helper_svm_check_intercept_param(SVM_EXIT_CLGI, 0);
5125: env->hflags2 &= ~HF2_GIF_MASK;
5126: }
5127:
5128: void helper_skinit(void)
5129: {
5130: helper_svm_check_intercept_param(SVM_EXIT_SKINIT, 0);
5131: /* XXX: not implemented */
5132: raise_exception(EXCP06_ILLOP);
5133: }
5134:
5135: void helper_invlpga(int aflag)
5136: {
5137: target_ulong addr;
5138: helper_svm_check_intercept_param(SVM_EXIT_INVLPGA, 0);
5139:
5140: if (aflag == 2)
5141: addr = EAX;
5142: else
5143: addr = (uint32_t)EAX;
5144:
5145: /* XXX: could use the ASID to see if it is needed to do the
5146: flush */
5147: tlb_flush_page(env, addr);
5148: }
5149:
5150: void helper_svm_check_intercept_param(uint32_t type, uint64_t param)
5151: {
5152: if (likely(!(env->hflags & HF_SVMI_MASK)))
5153: return;
5154: switch(type) {
5155: case SVM_EXIT_READ_CR0 ... SVM_EXIT_READ_CR0 + 8:
5156: if (env->intercept_cr_read & (1 << (type - SVM_EXIT_READ_CR0))) {
5157: helper_vmexit(type, param);
5158: }
5159: break;
5160: case SVM_EXIT_WRITE_CR0 ... SVM_EXIT_WRITE_CR0 + 8:
5161: if (env->intercept_cr_write & (1 << (type - SVM_EXIT_WRITE_CR0))) {
5162: helper_vmexit(type, param);
5163: }
5164: break;
5165: case SVM_EXIT_READ_DR0 ... SVM_EXIT_READ_DR0 + 7:
5166: if (env->intercept_dr_read & (1 << (type - SVM_EXIT_READ_DR0))) {
5167: helper_vmexit(type, param);
5168: }
5169: break;
5170: case SVM_EXIT_WRITE_DR0 ... SVM_EXIT_WRITE_DR0 + 7:
5171: if (env->intercept_dr_write & (1 << (type - SVM_EXIT_WRITE_DR0))) {
5172: helper_vmexit(type, param);
5173: }
5174: break;
5175: case SVM_EXIT_EXCP_BASE ... SVM_EXIT_EXCP_BASE + 31:
5176: if (env->intercept_exceptions & (1 << (type - SVM_EXIT_EXCP_BASE))) {
5177: helper_vmexit(type, param);
5178: }
5179: break;
5180: case SVM_EXIT_MSR:
5181: if (env->intercept & (1ULL << (SVM_EXIT_MSR - SVM_EXIT_INTR))) {
5182: /* FIXME: this should be read in at vmrun (faster this way?) */
5183: uint64_t addr = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.msrpm_base_pa));
5184: uint32_t t0, t1;
5185: switch((uint32_t)ECX) {
5186: case 0 ... 0x1fff:
5187: t0 = (ECX * 2) % 8;
5188: t1 = ECX / 8;
5189: break;
5190: case 0xc0000000 ... 0xc0001fff:
5191: t0 = (8192 + ECX - 0xc0000000) * 2;
5192: t1 = (t0 / 8);
5193: t0 %= 8;
5194: break;
5195: case 0xc0010000 ... 0xc0011fff:
5196: t0 = (16384 + ECX - 0xc0010000) * 2;
5197: t1 = (t0 / 8);
5198: t0 %= 8;
5199: break;
5200: default:
5201: helper_vmexit(type, param);
5202: t0 = 0;
5203: t1 = 0;
5204: break;
5205: }
5206: if (ldub_phys(addr + t1) & ((1 << param) << t0))
5207: helper_vmexit(type, param);
5208: }
5209: break;
5210: default:
5211: if (env->intercept & (1ULL << (type - SVM_EXIT_INTR))) {
5212: helper_vmexit(type, param);
5213: }
5214: break;
5215: }
5216: }
5217:
5218: void helper_svm_check_io(uint32_t port, uint32_t param,
5219: uint32_t next_eip_addend)
5220: {
5221: if (env->intercept & (1ULL << (SVM_EXIT_IOIO - SVM_EXIT_INTR))) {
5222: /* FIXME: this should be read in at vmrun (faster this way?) */
5223: uint64_t addr = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.iopm_base_pa));
5224: uint16_t mask = (1 << ((param >> 4) & 7)) - 1;
5225: if(lduw_phys(addr + port / 8) & (mask << (port & 7))) {
5226: /* next EIP */
5227: stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2),
5228: env->eip + next_eip_addend);
5229: helper_vmexit(SVM_EXIT_IOIO, param | (port << 16));
5230: }
5231: }
5232: }
5233:
5234: /* Note: currently only 32 bits of exit_code are used */
5235: void helper_vmexit(uint32_t exit_code, uint64_t exit_info_1)
5236: {
5237: uint32_t int_ctl;
5238:
5239: qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmexit(%08x, %016" PRIx64 ", %016" PRIx64 ", " TARGET_FMT_lx ")!\n",
5240: exit_code, exit_info_1,
5241: ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2)),
5242: EIP);
5243:
5244: if(env->hflags & HF_INHIBIT_IRQ_MASK) {
5245: stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_state), SVM_INTERRUPT_SHADOW_MASK);
5246: env->hflags &= ~HF_INHIBIT_IRQ_MASK;
5247: } else {
5248: stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_state), 0);
5249: }
5250:
5251: /* Save the VM state in the vmcb */
5252: svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.es),
5253: &env->segs[R_ES]);
5254: svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.cs),
5255: &env->segs[R_CS]);
5256: svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.ss),
5257: &env->segs[R_SS]);
5258: svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.ds),
5259: &env->segs[R_DS]);
5260:
5261: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.base), env->gdt.base);
5262: stl_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.limit), env->gdt.limit);
5263:
5264: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.base), env->idt.base);
5265: stl_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.limit), env->idt.limit);
5266:
5267: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.efer), env->efer);
5268: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr0), env->cr[0]);
5269: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr2), env->cr[2]);
5270: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr3), env->cr[3]);
5271: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr4), env->cr[4]);
5272:
5273: int_ctl = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl));
5274: int_ctl &= ~(V_TPR_MASK | V_IRQ_MASK);
5275: int_ctl |= env->v_tpr & V_TPR_MASK;
5276: if (env->interrupt_request & CPU_INTERRUPT_VIRQ)
5277: int_ctl |= V_IRQ_MASK;
5278: stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl), int_ctl);
5279:
5280: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rflags), compute_eflags());
5281: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rip), env->eip);
5282: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rsp), ESP);
5283: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rax), EAX);
5284: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr7), env->dr[7]);
5285: stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr6), env->dr[6]);
5286: stb_phys(env->vm_vmcb + offsetof(struct vmcb, save.cpl), env->hflags & HF_CPL_MASK);
5287:
5288: /* Reload the host state from vm_hsave */
5289: env->hflags2 &= ~(HF2_HIF_MASK | HF2_VINTR_MASK);
5290: env->hflags &= ~HF_SVMI_MASK;
5291: env->intercept = 0;
5292: env->intercept_exceptions = 0;
5293: env->interrupt_request &= ~CPU_INTERRUPT_VIRQ;
5294: env->tsc_offset = 0;
5295:
5296: env->gdt.base = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.base));
5297: env->gdt.limit = ldl_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.limit));
5298:
5299: env->idt.base = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.base));
5300: env->idt.limit = ldl_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.limit));
5301:
5302: cpu_x86_update_cr0(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr0)) | CR0_PE_MASK);
5303: cpu_x86_update_cr4(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr4)));
5304: cpu_x86_update_cr3(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr3)));
5305: /* we need to set the efer after the crs so the hidden flags get
5306: set properly */
5307: cpu_load_efer(env,
5308: ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.efer)));
5309: env->eflags = 0;
5310: load_eflags(ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rflags)),
5311: ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
5312: CC_OP = CC_OP_EFLAGS;
5313:
5314: svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.es),
5315: env, R_ES);
5316: svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.cs),
5317: env, R_CS);
5318: svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.ss),
5319: env, R_SS);
5320: svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.ds),
5321: env, R_DS);
5322:
5323: EIP = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rip));
5324: ESP = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rsp));
5325: EAX = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rax));
5326:
5327: env->dr[6] = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr6));
5328: env->dr[7] = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr7));
5329:
5330: /* other setups */
5331: cpu_x86_set_cpl(env, 0);
5332: stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_code), exit_code);
5333: stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_1), exit_info_1);
5334:
5335: env->hflags2 &= ~HF2_GIF_MASK;
5336: /* FIXME: Resets the current ASID register to zero (host ASID). */
5337:
5338: /* Clears the V_IRQ and V_INTR_MASKING bits inside the processor. */
5339:
5340: /* Clears the TSC_OFFSET inside the processor. */
5341:
5342: /* If the host is in PAE mode, the processor reloads the host's PDPEs
5343: from the page table indicated the host's CR3. If the PDPEs contain
5344: illegal state, the processor causes a shutdown. */
5345:
5346: /* Forces CR0.PE = 1, RFLAGS.VM = 0. */
5347: env->cr[0] |= CR0_PE_MASK;
5348: env->eflags &= ~VM_MASK;
5349:
5350: /* Disables all breakpoints in the host DR7 register. */
5351:
5352: /* Checks the reloaded host state for consistency. */
5353:
5354: /* If the host's rIP reloaded by #VMEXIT is outside the limit of the
5355: host's code segment or non-canonical (in the case of long mode), a
5356: #GP fault is delivered inside the host.) */
5357:
5358: /* remove any pending exception */
5359: env->exception_index = -1;
5360: env->error_code = 0;
5361: env->old_exception = -1;
5362:
5363: cpu_loop_exit();
5364: }
5365:
5366: #endif
5367:
5368: /* MMX/SSE */
5369: /* XXX: optimize by storing fptt and fptags in the static cpu state */
5370: void helper_enter_mmx(void)
5371: {
5372: env->fpstt = 0;
5373: *(uint32_t *)(env->fptags) = 0;
5374: *(uint32_t *)(env->fptags + 4) = 0;
5375: }
5376:
5377: void helper_emms(void)
5378: {
5379: /* set to empty state */
5380: *(uint32_t *)(env->fptags) = 0x01010101;
5381: *(uint32_t *)(env->fptags + 4) = 0x01010101;
5382: }
5383:
5384: /* XXX: suppress */
5385: void helper_movq(void *d, void *s)
5386: {
5387: *(uint64_t *)d = *(uint64_t *)s;
5388: }
5389:
5390: #define SHIFT 0
5391: #include "ops_sse.h"
5392:
5393: #define SHIFT 1
5394: #include "ops_sse.h"
5395:
5396: #define SHIFT 0
5397: #include "helper_template.h"
5398: #undef SHIFT
5399:
5400: #define SHIFT 1
5401: #include "helper_template.h"
5402: #undef SHIFT
5403:
5404: #define SHIFT 2
5405: #include "helper_template.h"
5406: #undef SHIFT
5407:
5408: #ifdef TARGET_X86_64
5409:
5410: #define SHIFT 3
5411: #include "helper_template.h"
5412: #undef SHIFT
5413:
5414: #endif
5415:
5416: /* bit operations */
5417: target_ulong helper_bsf(target_ulong t0)
5418: {
5419: int count;
5420: target_ulong res;
5421:
5422: res = t0;
5423: count = 0;
5424: while ((res & 1) == 0) {
5425: count++;
5426: res >>= 1;
5427: }
5428: return count;
5429: }
5430:
5431: target_ulong helper_bsr(target_ulong t0)
5432: {
5433: int count;
5434: target_ulong res, mask;
5435:
5436: res = t0;
5437: count = TARGET_LONG_BITS - 1;
5438: mask = (target_ulong)1 << (TARGET_LONG_BITS - 1);
5439: while ((res & mask) == 0) {
5440: count--;
5441: res <<= 1;
5442: }
5443: return count;
5444: }
5445:
5446:
5447: static int compute_all_eflags(void)
5448: {
5449: return CC_SRC;
5450: }
5451:
5452: static int compute_c_eflags(void)
5453: {
5454: return CC_SRC & CC_C;
5455: }
5456:
5457: uint32_t helper_cc_compute_all(int op)
5458: {
5459: switch (op) {
5460: default: /* should never happen */ return 0;
5461:
5462: case CC_OP_EFLAGS: return compute_all_eflags();
5463:
5464: case CC_OP_MULB: return compute_all_mulb();
5465: case CC_OP_MULW: return compute_all_mulw();
5466: case CC_OP_MULL: return compute_all_mull();
5467:
5468: case CC_OP_ADDB: return compute_all_addb();
5469: case CC_OP_ADDW: return compute_all_addw();
5470: case CC_OP_ADDL: return compute_all_addl();
5471:
5472: case CC_OP_ADCB: return compute_all_adcb();
5473: case CC_OP_ADCW: return compute_all_adcw();
5474: case CC_OP_ADCL: return compute_all_adcl();
5475:
5476: case CC_OP_SUBB: return compute_all_subb();
5477: case CC_OP_SUBW: return compute_all_subw();
5478: case CC_OP_SUBL: return compute_all_subl();
5479:
5480: case CC_OP_SBBB: return compute_all_sbbb();
5481: case CC_OP_SBBW: return compute_all_sbbw();
5482: case CC_OP_SBBL: return compute_all_sbbl();
5483:
5484: case CC_OP_LOGICB: return compute_all_logicb();
5485: case CC_OP_LOGICW: return compute_all_logicw();
5486: case CC_OP_LOGICL: return compute_all_logicl();
5487:
5488: case CC_OP_INCB: return compute_all_incb();
5489: case CC_OP_INCW: return compute_all_incw();
5490: case CC_OP_INCL: return compute_all_incl();
5491:
5492: case CC_OP_DECB: return compute_all_decb();
5493: case CC_OP_DECW: return compute_all_decw();
5494: case CC_OP_DECL: return compute_all_decl();
5495:
5496: case CC_OP_SHLB: return compute_all_shlb();
5497: case CC_OP_SHLW: return compute_all_shlw();
5498: case CC_OP_SHLL: return compute_all_shll();
5499:
5500: case CC_OP_SARB: return compute_all_sarb();
5501: case CC_OP_SARW: return compute_all_sarw();
5502: case CC_OP_SARL: return compute_all_sarl();
5503:
5504: #ifdef TARGET_X86_64
5505: case CC_OP_MULQ: return compute_all_mulq();
5506:
5507: case CC_OP_ADDQ: return compute_all_addq();
5508:
5509: case CC_OP_ADCQ: return compute_all_adcq();
5510:
5511: case CC_OP_SUBQ: return compute_all_subq();
5512:
5513: case CC_OP_SBBQ: return compute_all_sbbq();
5514:
5515: case CC_OP_LOGICQ: return compute_all_logicq();
5516:
5517: case CC_OP_INCQ: return compute_all_incq();
5518:
5519: case CC_OP_DECQ: return compute_all_decq();
5520:
5521: case CC_OP_SHLQ: return compute_all_shlq();
5522:
5523: case CC_OP_SARQ: return compute_all_sarq();
5524: #endif
5525: }
5526: }
5527:
5528: uint32_t helper_cc_compute_c(int op)
5529: {
5530: switch (op) {
5531: default: /* should never happen */ return 0;
5532:
5533: case CC_OP_EFLAGS: return compute_c_eflags();
5534:
5535: case CC_OP_MULB: return compute_c_mull();
5536: case CC_OP_MULW: return compute_c_mull();
5537: case CC_OP_MULL: return compute_c_mull();
5538:
5539: case CC_OP_ADDB: return compute_c_addb();
5540: case CC_OP_ADDW: return compute_c_addw();
5541: case CC_OP_ADDL: return compute_c_addl();
5542:
5543: case CC_OP_ADCB: return compute_c_adcb();
5544: case CC_OP_ADCW: return compute_c_adcw();
5545: case CC_OP_ADCL: return compute_c_adcl();
5546:
5547: case CC_OP_SUBB: return compute_c_subb();
5548: case CC_OP_SUBW: return compute_c_subw();
5549: case CC_OP_SUBL: return compute_c_subl();
5550:
5551: case CC_OP_SBBB: return compute_c_sbbb();
5552: case CC_OP_SBBW: return compute_c_sbbw();
5553: case CC_OP_SBBL: return compute_c_sbbl();
5554:
5555: case CC_OP_LOGICB: return compute_c_logicb();
5556: case CC_OP_LOGICW: return compute_c_logicw();
5557: case CC_OP_LOGICL: return compute_c_logicl();
5558:
5559: case CC_OP_INCB: return compute_c_incl();
5560: case CC_OP_INCW: return compute_c_incl();
5561: case CC_OP_INCL: return compute_c_incl();
5562:
5563: case CC_OP_DECB: return compute_c_incl();
5564: case CC_OP_DECW: return compute_c_incl();
5565: case CC_OP_DECL: return compute_c_incl();
5566:
5567: case CC_OP_SHLB: return compute_c_shlb();
5568: case CC_OP_SHLW: return compute_c_shlw();
5569: case CC_OP_SHLL: return compute_c_shll();
5570:
5571: case CC_OP_SARB: return compute_c_sarl();
5572: case CC_OP_SARW: return compute_c_sarl();
5573: case CC_OP_SARL: return compute_c_sarl();
5574:
5575: #ifdef TARGET_X86_64
5576: case CC_OP_MULQ: return compute_c_mull();
5577:
5578: case CC_OP_ADDQ: return compute_c_addq();
5579:
5580: case CC_OP_ADCQ: return compute_c_adcq();
5581:
5582: case CC_OP_SUBQ: return compute_c_subq();
5583:
5584: case CC_OP_SBBQ: return compute_c_sbbq();
5585:
5586: case CC_OP_LOGICQ: return compute_c_logicq();
5587:
5588: case CC_OP_INCQ: return compute_c_incl();
5589:
5590: case CC_OP_DECQ: return compute_c_incl();
5591:
5592: case CC_OP_SHLQ: return compute_c_shlq();
5593:
5594: case CC_OP_SARQ: return compute_c_sarl();
5595: #endif
5596: }
5597: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.