projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
x86/fpu/math-emu: Remove define layer for undocumented opcodes
[deliverable/linux.git] / arch / x86 / math-emu / fpu_entry.c
1 /*---------------------------------------------------------------------------+
2 | fpu_entry.c |
3 | |
4 | The entry functions for wm-FPU-emu |
5 | |
6 | Copyright (C) 1992,1993,1994,1996,1997 |
7 | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
8 | E-mail billm@suburbia.net |
9 | |
10 | See the files "README" and "COPYING" for further copyright and warranty |
11 | information. |
12 | |
13 +---------------------------------------------------------------------------*/
14
15 /*---------------------------------------------------------------------------+
16 | Note: |
17 | The file contains code which accesses user memory. |
18 | Emulator static data may change when user memory is accessed, due to |
19 | other processes using the emulator while swapping is in progress. |
20 +---------------------------------------------------------------------------*/
21
22 /*---------------------------------------------------------------------------+
23 | math_emulate(), restore_i387_soft() and save_i387_soft() are the only |
24 | entry points for wm-FPU-emu. |
25 +---------------------------------------------------------------------------*/
26
27 #include <linux/signal.h>
28 #include <linux/regset.h>
29
30 #include <asm/uaccess.h>
31 #include <asm/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 /* WARNING: "u" entries are not documented by Intel in their 80486 manual
44 and may not work on FPU clones or later Intel FPUs.
45 Changes to support them provided by Linus Torvalds. */
46
47 static FUNC const st_instr_table[64] = {
48 /* Opcode: d8 d9 da db */
49 /* dc dd de df */
50 /* c0..7 */ fadd__, fld_i_, __BAD__, __BAD__,
51 /* c0..7 */ fadd_i, ffree_, faddp_, ffreep,/*u*/
52 /* c8..f */ fmul__, fxch_i, __BAD__, __BAD__,
53 /* c8..f */ fmul_i, fxch_i,/*u*/ fmulp_, fxch_i,/*u*/
54 /* d0..7 */ fcom_st, fp_nop, __BAD__, __BAD__,
55 /* d0..7 */ fcom_st,/*u*/ fst_i_, fcompst,/*u*/ fstp_i,/*u*/
56 /* d8..f */ fcompst, fstp_i,/*u*/ __BAD__, __BAD__,
57 /* d8..f */ fcompst,/*u*/ fstp_i, fcompp, fstp_i,/*u*/
58 /* e0..7 */ fsub__, FPU_etc, __BAD__, finit_,
59 /* e0..7 */ fsubri, fucom_, fsubrp, fstsw_,
60 /* e8..f */ fsubr_, fconst, fucompp, __BAD__,
61 /* e8..f */ fsub_i, fucomp, fsubp_, __BAD__,
62 /* f0..7 */ fdiv__, FPU_triga, __BAD__, __BAD__,
63 /* f0..7 */ fdivri, __BAD__, fdivrp, __BAD__,
64 /* f8..f */ fdivr_, FPU_trigb, __BAD__, __BAD__,
65 /* f8..f */ fdiv_i, __BAD__, fdivp_, __BAD__,
66 };
67
68 #define _NONE_ 0 /* Take no special action */
69 #define _REG0_ 1 /* Need to check for not empty st(0) */
70 #define _REGI_ 2 /* Need to check for not empty st(0) and st(rm) */
71 #define _REGi_ 0 /* Uses st(rm) */
72 #define _PUSH_ 3 /* Need to check for space to push onto stack */
73 #define _null_ 4 /* Function illegal or not implemented */
74 #define _REGIi 5 /* Uses st(0) and st(rm), result to st(rm) */
75 #define _REGIp 6 /* Uses st(0) and st(rm), result to st(rm) then pop */
76 #define _REGIc 0 /* Compare st(0) and st(rm) */
77 #define _REGIn 0 /* Uses st(0) and st(rm), but handle checks later */
78
79 static u_char const type_table[64] = {
80 _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
81 _REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
82 _REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
83 _REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
84 _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
85 _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
86 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
87 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
88 };
89
90 #ifdef RE_ENTRANT_CHECKING
91 u_char emulating = 0;
92 #endif /* RE_ENTRANT_CHECKING */
93
94 static int valid_prefix(u_char *Byte, u_char __user ** fpu_eip,
95 overrides * override);
96
97 void math_emulate(struct math_emu_info *info)
98 {
99 u_char FPU_modrm, byte1;
100 unsigned short code;
101 fpu_addr_modes addr_modes;
102 int unmasked;
103 FPU_REG loaded_data;
104 FPU_REG *st0_ptr;
105 u_char loaded_tag, st0_tag;
106 void __user *data_address;
107 struct address data_sel_off;
108 struct address entry_sel_off;
109 unsigned long code_base = 0;
110 unsigned long code_limit = 0; /* Initialized to stop compiler warnings */
111 struct desc_struct code_descriptor;
112 struct fpu *fpu = &current->thread.fpu;
113
114 fpu__activate_curr(fpu);
115
116 #ifdef RE_ENTRANT_CHECKING
117 if (emulating) {
118 printk("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
119 }
120 RE_ENTRANT_CHECK_ON;
121 #endif /* RE_ENTRANT_CHECKING */
122
123 FPU_info = info;
124
125 FPU_ORIG_EIP = FPU_EIP;
126
127 if ((FPU_EFLAGS & 0x00020000) != 0) {
128 /* Virtual 8086 mode */
129 addr_modes.default_mode = VM86;
130 FPU_EIP += code_base = FPU_CS << 4;
131 code_limit = code_base + 0xffff; /* Assumes code_base <= 0xffff0000 */
132 } else if (FPU_CS == __USER_CS && FPU_DS == __USER_DS) {
133 addr_modes.default_mode = 0;
134 } else if (FPU_CS == __KERNEL_CS) {
135 printk("math_emulate: %04x:%08lx\n", FPU_CS, FPU_EIP);
136 panic("Math emulation needed in kernel");
137 } else {
138
139 if ((FPU_CS & 4) != 4) { /* Must be in the LDT */
140 /* Can only handle segmented addressing via the LDT
141 for now, and it must be 16 bit */
142 printk("FPU emulator: Unsupported addressing mode\n");
143 math_abort(FPU_info, SIGILL);
144 }
145
146 code_descriptor = FPU_get_ldt_descriptor(FPU_CS);
147 if (SEG_D_SIZE(code_descriptor)) {
148 /* The above test may be wrong, the book is not clear */
149 /* Segmented 32 bit protected mode */
150 addr_modes.default_mode = SEG32;
151 } else {
152 /* 16 bit protected mode */
153 addr_modes.default_mode = PM16;
154 }
155 FPU_EIP += code_base = SEG_BASE_ADDR(code_descriptor);
156 code_limit = code_base
157 + (SEG_LIMIT(code_descriptor) +
158 1) * SEG_GRANULARITY(code_descriptor)
159 - 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 }
Linux kernel - Deliverables
This page took 0.048197 seconds and 6 git commands to generate.