LXR linux/arch/x86/math-emu/fpu

   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
  61static 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
  74static 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
 102static 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
 115static 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
 129u_char emulating = 0;
 130#endif /* RE_ENTRANT_CHECKING */
 131
 132static int valid_prefix(u_char *Byte, u_char __user ** fpu_eip,
 133                        overrides * override);
 134
 135void 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. */
 587static 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
 663void 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
 680int 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
 732int 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}
 769