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