?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / arch / x86 / math-emu / fpu_entry.c
blob760baeea5f07c9ad13858d19faa1060a7de3d849
1 /*---------------------------------------------------------------------------+
2 | fpu_entry.c |
3 | |
4 | The entry functions for wm-FPU-emu |
5 | |
6 | Copyright (C) 1992,1993,1994,1996,1997 |
7 | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
8 | E-mail billm@suburbia.net |
9 | |
10 | See the files "README" and "COPYING" for further copyright and warranty |
11 | information. |
12 | |
13 +---------------------------------------------------------------------------*/
14
15 /*---------------------------------------------------------------------------+
16 | Note: |
17 | The file contains code which accesses user memory. |
18 | Emulator static data may change when user memory is accessed, due to |
19 | other processes using the emulator while swapping is in progress. |
20 +---------------------------------------------------------------------------*/
21
22 /*---------------------------------------------------------------------------+
23 | math_emulate(), restore_i387_soft() and save_i387_soft() are the only |
24 | entry points for wm-FPU-emu. |
25 +---------------------------------------------------------------------------*/
26
27 #include <linux/signal.h>
28 #include <linux/regset.h>
29
30 #include <asm/uaccess.h>
31 #include <asm/desc.h>
32 #include <asm/user.h>
33
34 #include "fpu_system.h"
35 #include "fpu_emu.h"
36 #include "exception.h"
37 #include "control_w.h"
38 #include "status_w.h"
39
40 #define __BAD__ FPU_illegal /* Illegal on an 80486, causes SIGILL */
41
42 #ifndef NO_UNDOC_CODE /* Un-documented FPU op-codes supported by default. */
43
44 /* WARNING: These codes are not documented by Intel in their 80486 manual
45 and may not work on FPU clones or later Intel FPUs. */
46
47 /* Changes to support the un-doc codes provided by Linus Torvalds. */
48
49 #define _d9_d8_ fstp_i /* unofficial code (19) */
50 #define _dc_d0_ fcom_st /* unofficial code (14) */
51 #define _dc_d8_ fcompst /* unofficial code (1c) */
52 #define _dd_c8_ fxch_i /* unofficial code (0d) */
53 #define _de_d0_ fcompst /* unofficial code (16) */
54 #define _df_c0_ ffreep /* unofficial code (07) ffree + pop */
55 #define _df_c8_ fxch_i /* unofficial code (0f) */
56 #define _df_d0_ fstp_i /* unofficial code (17) */
57 #define _df_d8_ fstp_i /* unofficial code (1f) */
58
59 static FUNC const st_instr_table[64] = {
60 fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, _df_c0_,
61 fmul__, fxch_i, __BAD__, __BAD__, fmul_i, _dd_c8_, fmulp_, _df_c8_,
62 fcom_st, fp_nop, __BAD__, __BAD__, _dc_d0_, fst_i_, _de_d0_, _df_d0_,
63 fcompst, _d9_d8_, __BAD__, __BAD__, _dc_d8_, fstp_i, fcompp, _df_d8_,
64 fsub__, FPU_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
65 fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
66 fdiv__, FPU_triga, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
67 fdivr_, FPU_trigb, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
68 };
69
70 #else /* Support only documented FPU op-codes */
71
72 static FUNC const st_instr_table[64] = {
73 fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, __BAD__,
74 fmul__, fxch_i, __BAD__, __BAD__, fmul_i, __BAD__, fmulp_, __BAD__,
75 fcom_st, fp_nop, __BAD__, __BAD__, __BAD__, fst_i_, __BAD__, __BAD__,
76 fcompst, __BAD__, __BAD__, __BAD__, __BAD__, fstp_i, fcompp, __BAD__,
77 fsub__, FPU_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
78 fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
79 fdiv__, FPU_triga, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
80 fdivr_, FPU_trigb, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
81 };
82
83 #endif /* NO_UNDOC_CODE */
84
85 #define _NONE_ 0 /* Take no special action */
86 #define _REG0_ 1 /* Need to check for not empty st(0) */
87 #define _REGI_ 2 /* Need to check for not empty st(0) and st(rm) */
88 #define _REGi_ 0 /* Uses st(rm) */
89 #define _PUSH_ 3 /* Need to check for space to push onto stack */
90 #define _null_ 4 /* Function illegal or not implemented */
91 #define _REGIi 5 /* Uses st(0) and st(rm), result to st(rm) */
92 #define _REGIp 6 /* Uses st(0) and st(rm), result to st(rm) then pop */
93 #define _REGIc 0 /* Compare st(0) and st(rm) */
94 #define _REGIn 0 /* Uses st(0) and st(rm), but handle checks later */
95
96 #ifndef NO_UNDOC_CODE
97
98 /* Un-documented FPU op-codes supported by default. (see above) */
99
100 static u_char const type_table[64] = {
101 _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
102 _REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
103 _REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
104 _REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
105 _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
106 _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
107 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
108 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
109 };
110
111 #else /* Support only documented FPU op-codes */
112
113 static u_char const type_table[64] = {
114 _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _null_,
115 _REGI_, _REGIn, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
116 _REGIc, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_,
117 _REGIc, _null_, _null_, _null_, _null_, _REG0_, _REGIc, _null_,
118 _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
119 _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
120 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
121 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
122 };
123
124 #endif /* NO_UNDOC_CODE */
125
126 #ifdef RE_ENTRANT_CHECKING
127 u_char emulating = 0;
128 #endif /* RE_ENTRANT_CHECKING */
129
130 static int valid_prefix(u_char *Byte, u_char __user ** fpu_eip,
131 overrides * override);
132
133 asmlinkage void math_emulate(long arg)
134 {
135 u_char FPU_modrm, byte1;
136 unsigned short code;
137 fpu_addr_modes addr_modes;
138 int unmasked;
139 FPU_REG loaded_data;
140 FPU_REG *st0_ptr;
141 u_char loaded_tag, st0_tag;
142 void __user *data_address;
143 struct address data_sel_off;
144 struct address entry_sel_off;
145 unsigned long code_base = 0;
146 unsigned long code_limit = 0; /* Initialized to stop compiler warnings */
147 struct desc_struct code_descriptor;
148
149 #ifdef RE_ENTRANT_CHECKING
150 if (emulating) {
151 printk("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
152 }
153 RE_ENTRANT_CHECK_ON;
154 #endif /* RE_ENTRANT_CHECKING */
155
156 if (!used_math()) {
157 finit();
158 set_used_math();
159 }
160
161 SETUP_DATA_AREA(arg);
162
163 FPU_ORIG_EIP = FPU_EIP;
164
165 if ((FPU_EFLAGS & 0x00020000) != 0) {
166 /* Virtual 8086 mode */
167 addr_modes.default_mode = VM86;
168 FPU_EIP += code_base = FPU_CS << 4;
169 code_limit = code_base + 0xffff; /* Assumes code_base <= 0xffff0000 */
170 } else if (FPU_CS == __USER_CS && FPU_DS == __USER_DS) {
171 addr_modes.default_mode = 0;
172 } else if (FPU_CS == __KERNEL_CS) {
173 printk("math_emulate: %04x:%08lx\n", FPU_CS, FPU_EIP);
174 panic("Math emulation needed in kernel");
175 } else {
176
177 if ((FPU_CS & 4) != 4) { /* Must be in the LDT */
178 /* Can only handle segmented addressing via the LDT
179 for now, and it must be 16 bit */
180 printk("FPU emulator: Unsupported addressing mode\n");
181 math_abort(FPU_info, SIGILL);
182 }
183
184 code_descriptor = LDT_DESCRIPTOR(FPU_CS);
185 if (SEG_D_SIZE(code_descriptor)) {
186 /* The above test may be wrong, the book is not clear */
187 /* Segmented 32 bit protected mode */
188 addr_modes.default_mode = SEG32;
189 } else {
190 /* 16 bit protected mode */
191 addr_modes.default_mode = PM16;
192 }
193 FPU_EIP += code_base = SEG_BASE_ADDR(code_descriptor);
194 code_limit = code_base
195 + (SEG_LIMIT(code_descriptor) +
196 1) * SEG_GRANULARITY(code_descriptor)
197 - 1;
198 if (code_limit < code_base)
199 code_limit = 0xffffffff;
200 }
201
202 FPU_lookahead = !(FPU_EFLAGS & X86_EFLAGS_TF);
203
204 if (!valid_prefix(&byte1, (u_char __user **) & FPU_EIP,
205 &addr_modes.override)) {
206 RE_ENTRANT_CHECK_OFF;
207 printk
208 ("FPU emulator: Unknown prefix byte 0x%02x, probably due to\n"
209 "FPU emulator: self-modifying code! (emulation impossible)\n",
210 byte1);
211 RE_ENTRANT_CHECK_ON;
212 EXCEPTION(EX_INTERNAL | 0x126);
213 math_abort(FPU_info, SIGILL);
214 }
215
216 do_another_FPU_instruction:
217
218 no_ip_update = 0;
219
220 FPU_EIP++; /* We have fetched the prefix and first code bytes. */
221
222 if (addr_modes.default_mode) {
223 /* This checks for the minimum instruction bytes.
224 We also need to check any extra (address mode) code access. */
225 if (FPU_EIP > code_limit)
226 math_abort(FPU_info, SIGSEGV);
227 }
228
229 if ((byte1 & 0xf8) != 0xd8) {
230 if (byte1 == FWAIT_OPCODE) {
231 if (partial_status & SW_Summary)
232 goto do_the_FPU_interrupt;
233 else
234 goto FPU_fwait_done;
235 }
236 #ifdef PARANOID
237 EXCEPTION(EX_INTERNAL | 0x128);
238 math_abort(FPU_info, SIGILL);
239 #endif /* PARANOID */
240 }
241
242 RE_ENTRANT_CHECK_OFF;
243 FPU_code_access_ok(1);
244 FPU_get_user(FPU_modrm, (u_char __user *) FPU_EIP);
245 RE_ENTRANT_CHECK_ON;
246 FPU_EIP++;
247
248 if (partial_status & SW_Summary) {
249 /* Ignore the error for now if the current instruction is a no-wait
250 control instruction */
251 /* The 80486 manual contradicts itself on this topic,
252 but a real 80486 uses the following instructions:
253 fninit, fnstenv, fnsave, fnstsw, fnstenv, fnclex.
254 */
255 code = (FPU_modrm << 8) | byte1;
256 if (!((((code & 0xf803) == 0xe003) || /* fnclex, fninit, fnstsw */
257 (((code & 0x3003) == 0x3001) && /* fnsave, fnstcw, fnstenv,
258 fnstsw */
259 ((code & 0xc000) != 0xc000))))) {
260 /*
261 * We need to simulate the action of the kernel to FPU
262 * interrupts here.
263 */
264 do_the_FPU_interrupt:
265
266 FPU_EIP = FPU_ORIG_EIP; /* Point to current FPU instruction. */
267
268 RE_ENTRANT_CHECK_OFF;
269 current->thread.trap_no = 16;
270 current->thread.error_code = 0;
271 send_sig(SIGFPE, current, 1);
272 return;
273 }
274 }
275
276 entry_sel_off.offset = FPU_ORIG_EIP;
277 entry_sel_off.selector = FPU_CS;
278 entry_sel_off.opcode = (byte1 << 8) | FPU_modrm;
279
280 FPU_rm = FPU_modrm & 7;
281
282 if (FPU_modrm < 0300) {
283 /* All of these instructions use the mod/rm byte to get a data address */
284
285 if ((addr_modes.default_mode & SIXTEEN)
286 ^ (addr_modes.override.address_size == ADDR_SIZE_PREFIX))
287 data_address =
288 FPU_get_address_16(FPU_modrm, &FPU_EIP,
289 &data_sel_off, addr_modes);
290 else
291 data_address =
292 FPU_get_address(FPU_modrm, &FPU_EIP, &data_sel_off,
293 addr_modes);
294
295 if (addr_modes.default_mode) {
296 if (FPU_EIP - 1 > code_limit)
297 math_abort(FPU_info, SIGSEGV);
298 }
299
300 if (!(byte1 & 1)) {
301 unsigned short status1 = partial_status;
302
303 st0_ptr = &st(0);
304 st0_tag = FPU_gettag0();
305
306 /* Stack underflow has priority */
307 if (NOT_EMPTY_ST0) {
308 if (addr_modes.default_mode & PROTECTED) {
309 /* This table works for 16 and 32 bit protected mode */
310 if (access_limit <
311 data_sizes_16[(byte1 >> 1) & 3])
312 math_abort(FPU_info, SIGSEGV);
313 }
314
315 unmasked = 0; /* Do this here to stop compiler warnings. */
316 switch ((byte1 >> 1) & 3) {
317 case 0:
318 unmasked =
319 FPU_load_single((float __user *)
320 data_address,
321 &loaded_data);
322 loaded_tag = unmasked & 0xff;
323 unmasked &= ~0xff;
324 break;
325 case 1:
326 loaded_tag =
327 FPU_load_int32((long __user *)
328 data_address,
329 &loaded_data);
330 break;
331 case 2:
332 unmasked =
333 FPU_load_double((double __user *)
334 data_address,
335 &loaded_data);
336 loaded_tag = unmasked & 0xff;
337 unmasked &= ~0xff;
338 break;
339 case 3:
340 default: /* Used here to suppress gcc warnings. */
341 loaded_tag =
342 FPU_load_int16((short __user *)
343 data_address,
344 &loaded_data);
345 break;
346 }
347
348 /* No more access to user memory, it is safe
349 to use static data now */
350
351 /* NaN operands have the next priority. */
352 /* We have to delay looking at st(0) until after
353 loading the data, because that data might contain an SNaN */
354 if (((st0_tag == TAG_Special) && isNaN(st0_ptr))
355 || ((loaded_tag == TAG_Special)
356 && isNaN(&loaded_data))) {
357 /* Restore the status word; we might have loaded a
358 denormal. */
359 partial_status = status1;
360 if ((FPU_modrm & 0x30) == 0x10) {
361 /* fcom or fcomp */
362 EXCEPTION(EX_Invalid);
363 setcc(SW_C3 | SW_C2 | SW_C0);
364 if ((FPU_modrm & 0x08)
365 && (control_word &
366 CW_Invalid))
367 FPU_pop(); /* fcomp, masked, so we pop. */
368 } else {
369 if (loaded_tag == TAG_Special)
370 loaded_tag =
371 FPU_Special
372 (&loaded_data);
373 #ifdef PECULIAR_486
374 /* This is not really needed, but gives behaviour
375 identical to an 80486 */
376 if ((FPU_modrm & 0x28) == 0x20)
377 /* fdiv or fsub */
378 real_2op_NaN
379 (&loaded_data,
380 loaded_tag, 0,
381 &loaded_data);
382 else
383 #endif /* PECULIAR_486 */
384 /* fadd, fdivr, fmul, or fsubr */
385 real_2op_NaN
386 (&loaded_data,
387 loaded_tag, 0,
388 st0_ptr);
389 }
390 goto reg_mem_instr_done;
391 }
392
393 if (unmasked && !((FPU_modrm & 0x30) == 0x10)) {
394 /* Is not a comparison instruction. */
395 if ((FPU_modrm & 0x38) == 0x38) {
396 /* fdivr */
397 if ((st0_tag == TAG_Zero) &&
398 ((loaded_tag == TAG_Valid)
399 || (loaded_tag ==
400 TAG_Special
401 &&
402 isdenormal
403 (&loaded_data)))) {
404 if (FPU_divide_by_zero
405 (0,
406 getsign
407 (&loaded_data))
408 < 0) {
409 /* We use the fact here that the unmasked
410 exception in the loaded data was for a
411 denormal operand */
412 /* Restore the state of the denormal op bit */
413 partial_status
414 &=
415 ~SW_Denorm_Op;
416 partial_status
417 |=
418 status1 &
419 SW_Denorm_Op;
420 } else
421 setsign(st0_ptr,
422 getsign
423 (&loaded_data));
424 }
425 }
426 goto reg_mem_instr_done;
427 }
428
429 switch ((FPU_modrm >> 3) & 7) {
430 case 0: /* fadd */
431 clear_C1();
432 FPU_add(&loaded_data, loaded_tag, 0,
433 control_word);
434 break;
435 case 1: /* fmul */
436 clear_C1();
437 FPU_mul(&loaded_data, loaded_tag, 0,
438 control_word);
439 break;
440 case 2: /* fcom */
441 FPU_compare_st_data(&loaded_data,
442 loaded_tag);
443 break;
444 case 3: /* fcomp */
445 if (!FPU_compare_st_data
446 (&loaded_data, loaded_tag)
447 && !unmasked)
448 FPU_pop();
449 break;
450 case 4: /* fsub */
451 clear_C1();
452 FPU_sub(LOADED | loaded_tag,
453 (int)&loaded_data,
454 control_word);
455 break;
456 case 5: /* fsubr */
457 clear_C1();
458 FPU_sub(REV | LOADED | loaded_tag,
459 (int)&loaded_data,
460 control_word);
461 break;
462 case 6: /* fdiv */
463 clear_C1();
464 FPU_div(LOADED | loaded_tag,
465 (int)&loaded_data,
466 control_word);
467 break;
468 case 7: /* fdivr */
469 clear_C1();
470 if (st0_tag == TAG_Zero)
471 partial_status = status1; /* Undo any denorm tag,
472 zero-divide has priority. */
473 FPU_div(REV | LOADED | loaded_tag,
474 (int)&loaded_data,
475 control_word);
476 break;
477 }
478 } else {
479 if ((FPU_modrm & 0x30) == 0x10) {
480 /* The instruction is fcom or fcomp */
481 EXCEPTION(EX_StackUnder);
482 setcc(SW_C3 | SW_C2 | SW_C0);
483 if ((FPU_modrm & 0x08)
484 && (control_word & CW_Invalid))
485 FPU_pop(); /* fcomp */
486 } else
487 FPU_stack_underflow();
488 }
489 reg_mem_instr_done:
490 operand_address = data_sel_off;
491 } else {
492 if (!(no_ip_update =
493 FPU_load_store(((FPU_modrm & 0x38) | (byte1 & 6))
494 >> 1, addr_modes, data_address))) {
495 operand_address = data_sel_off;
496 }
497 }
498
499 } else {
500 /* None of these instructions access user memory */
501 u_char instr_index = (FPU_modrm & 0x38) | (byte1 & 7);
502
503 #ifdef PECULIAR_486
504 /* This is supposed to be undefined, but a real 80486 seems
505 to do this: */
506 operand_address.offset = 0;
507 operand_address.selector = FPU_DS;
508 #endif /* PECULIAR_486 */
509
510 st0_ptr = &st(0);
511 st0_tag = FPU_gettag0();
512 switch (type_table[(int)instr_index]) {
513 case _NONE_: /* also _REGIc: _REGIn */
514 break;
515 case _REG0_:
516 if (!NOT_EMPTY_ST0) {
517 FPU_stack_underflow();
518 goto FPU_instruction_done;
519 }
520 break;
521 case _REGIi:
522 if (!NOT_EMPTY_ST0 || !NOT_EMPTY(FPU_rm)) {
523 FPU_stack_underflow_i(FPU_rm);
524 goto FPU_instruction_done;
525 }
526 break;
527 case _REGIp:
528 if (!NOT_EMPTY_ST0 || !NOT_EMPTY(FPU_rm)) {
529 FPU_stack_underflow_pop(FPU_rm);
530 goto FPU_instruction_done;
531 }
532 break;
533 case _REGI_:
534 if (!NOT_EMPTY_ST0 || !NOT_EMPTY(FPU_rm)) {
535 FPU_stack_underflow();
536 goto FPU_instruction_done;
537 }
538 break;
539 case _PUSH_: /* Only used by the fld st(i) instruction */
540 break;
541 case _null_:
542 FPU_illegal();
543 goto FPU_instruction_done;
544 default:
545 EXCEPTION(EX_INTERNAL | 0x111);
546 goto FPU_instruction_done;
547 }
548 (*st_instr_table[(int)instr_index]) ();
549
550 FPU_instruction_done:
551 ;
552 }
553
554 if (!no_ip_update)
555 instruction_address = entry_sel_off;
556
557 FPU_fwait_done:
558
559 #ifdef DEBUG
560 RE_ENTRANT_CHECK_OFF;
561 FPU_printall();
562 RE_ENTRANT_CHECK_ON;
563 #endif /* DEBUG */
564
565 if (FPU_lookahead && !need_resched()) {
566 FPU_ORIG_EIP = FPU_EIP - code_base;
567 if (valid_prefix(&byte1, (u_char __user **) & FPU_EIP,
568 &addr_modes.override))
569 goto do_another_FPU_instruction;
570 }
571
572 if (addr_modes.default_mode)
573 FPU_EIP -= code_base;
574
575 RE_ENTRANT_CHECK_OFF;
576 }
577
578 /* Support for prefix bytes is not yet complete. To properly handle
579 all prefix bytes, further changes are needed in the emulator code
580 which accesses user address space. Access to separate segments is
581 important for msdos emulation. */
582 static int valid_prefix(u_char *Byte, u_char __user **fpu_eip,
583 overrides * override)
584 {
585 u_char byte;
586 u_char __user *ip = *fpu_eip;
587
588 *override = (overrides) {
589 0, 0, PREFIX_DEFAULT}; /* defaults */
590
591 RE_ENTRANT_CHECK_OFF;
592 FPU_code_access_ok(1);
593 FPU_get_user(byte, ip);
594 RE_ENTRANT_CHECK_ON;
595
596 while (1) {
597 switch (byte) {
598 case ADDR_SIZE_PREFIX:
599 override->address_size = ADDR_SIZE_PREFIX;
600 goto do_next_byte;
601
602 case OP_SIZE_PREFIX:
603 override->operand_size = OP_SIZE_PREFIX;
604 goto do_next_byte;
605
606 case PREFIX_CS:
607 override->segment = PREFIX_CS_;
608 goto do_next_byte;
609 case PREFIX_ES:
610 override->segment = PREFIX_ES_;
611 goto do_next_byte;
612 case PREFIX_SS:
613 override->segment = PREFIX_SS_;
614 goto do_next_byte;
615 case PREFIX_FS:
616 override->segment = PREFIX_FS_;
617 goto do_next_byte;
618 case PREFIX_GS:
619 override->segment = PREFIX_GS_;
620 goto do_next_byte;
621 case PREFIX_DS:
622 override->segment = PREFIX_DS_;
623 goto do_next_byte;
624
625 /* lock is not a valid prefix for FPU instructions,
626 let the cpu handle it to generate a SIGILL. */
627 /* case PREFIX_LOCK: */
628
629 /* rep.. prefixes have no meaning for FPU instructions */
630 case PREFIX_REPE:
631 case PREFIX_REPNE:
632
633 do_next_byte:
634 ip++;
635 RE_ENTRANT_CHECK_OFF;
636 FPU_code_access_ok(1);
637 FPU_get_user(byte, ip);
638 RE_ENTRANT_CHECK_ON;
639 break;
640 case FWAIT_OPCODE:
641 *Byte = byte;
642 return 1;
643 default:
644 if ((byte & 0xf8) == 0xd8) {
645 *Byte = byte;
646 *fpu_eip = ip;
647 return 1;
648 } else {
649 /* Not a valid sequence of prefix bytes followed by
650 an FPU instruction. */
651 *Byte = byte; /* Needed for error message. */
652 return 0;
653 }
654 }
655 }
656 }
657
658 void math_abort(struct info *info, unsigned int signal)
659 {
660 FPU_EIP = FPU_ORIG_EIP;
661 current->thread.trap_no = 16;
662 current->thread.error_code = 0;
663 send_sig(signal, current, 1);
664 RE_ENTRANT_CHECK_OFF;
665 __asm__("movl %0,%%esp ; ret": :"g"(((long)info) - 4));
666 #ifdef PARANOID
667 printk("ERROR: wm-FPU-emu math_abort failed!\n");
668 #endif /* PARANOID */
669 }
670
671 #define S387 ((struct i387_soft_struct *)s387)
672 #define sstatus_word() \
673 ((S387->swd & ~SW_Top & 0xffff) | ((S387->ftop << SW_Top_Shift) & SW_Top))
674
675 int fpregs_soft_set(struct task_struct *target,
676 const struct user_regset *regset,
677 unsigned int pos, unsigned int count,
678 const void *kbuf, const void __user *ubuf)
679 {
680 struct i387_soft_struct *s387 = &target->thread.i387.soft;
681 void *space = s387->st_space;
682 int ret;
683 int offset, other, i, tags, regnr, tag, newtop;
684
685 RE_ENTRANT_CHECK_OFF;
686 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, s387, 0,
687 offsetof(struct i387_soft_struct, st_space));
688 RE_ENTRANT_CHECK_ON;
689
690 if (ret)
691 return ret;
692
693 S387->ftop = (S387->swd >> SW_Top_Shift) & 7;
694 offset = (S387->ftop & 7) * 10;
695 other = 80 - offset;
696
697 RE_ENTRANT_CHECK_OFF;
698
699 /* Copy all registers in stack order. */
700 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
701 space + offset, 0, other);
702 if (!ret && offset)
703 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
704 space, 0, offset);
705
706 RE_ENTRANT_CHECK_ON;
707
708 /* The tags may need to be corrected now. */
709 tags = S387->twd;
710 newtop = S387->ftop;
711 for (i = 0; i < 8; i++) {
712 regnr = (i + newtop) & 7;
713 if (((tags >> ((regnr & 7) * 2)) & 3) != TAG_Empty) {
714 /* The loaded data over-rides all other cases. */
715 tag =
716 FPU_tagof((FPU_REG *) ((u_char *) S387->st_space +
717 10 * regnr));
718 tags &= ~(3 << (regnr * 2));
719 tags |= (tag & 3) << (regnr * 2);
720 }
721 }
722 S387->twd = tags;
723
724 return ret;
725 }
726
727 int fpregs_soft_get(struct task_struct *target,
728 const struct user_regset *regset,
729 unsigned int pos, unsigned int count,
730 void *kbuf, void __user *ubuf)
731 {
732 struct i387_soft_struct *s387 = &target->thread.i387.soft;
733 const void *space = s387->st_space;
734 int ret;
735 int offset = (S387->ftop & 7) * 10, other = 80 - offset;
736
737 RE_ENTRANT_CHECK_OFF;
738
739 #ifdef PECULIAR_486
740 S387->cwd &= ~0xe080;
741 /* An 80486 sets nearly all of the reserved bits to 1. */
742 S387->cwd |= 0xffff0040;
743 S387->swd = sstatus_word() | 0xffff0000;
744 S387->twd |= 0xffff0000;
745 S387->fcs &= ~0xf8000000;
746 S387->fos |= 0xffff0000;
747 #endif /* PECULIAR_486 */
748
749 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, s387, 0,
750 offsetof(struct i387_soft_struct, st_space));
751
752 /* Copy all registers in stack order. */
753 if (!ret)
754 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
755 space + offset, 0, other);
756 if (!ret)
757 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
758 space, 0, offset);
759
760 RE_ENTRANT_CHECK_ON;
761
762 return ret;
763 }
mah project overlay