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