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