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