projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[deliverable/linux.git] / arch / x86 / math-emu / reg_ld_str.c
1 /*---------------------------------------------------------------------------+
2 | reg_ld_str.c |
3 | |
4 | All of the functions which transfer data between user memory and FPU_REGs.|
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 | |
11 +---------------------------------------------------------------------------*/
12
13 /*---------------------------------------------------------------------------+
14 | Note: |
15 | The file contains code which accesses user memory. |
16 | Emulator static data may change when user memory is accessed, due to |
17 | other processes using the emulator while swapping is in progress. |
18 +---------------------------------------------------------------------------*/
19
20 #include "fpu_emu.h"
21
22 #include <asm/uaccess.h>
23
24 #include "fpu_system.h"
25 #include "exception.h"
26 #include "reg_constant.h"
27 #include "control_w.h"
28 #include "status_w.h"
29
30 #define DOUBLE_Emax 1023 /* largest valid exponent */
31 #define DOUBLE_Ebias 1023
32 #define DOUBLE_Emin (-1022) /* smallest valid exponent */
33
34 #define SINGLE_Emax 127 /* largest valid exponent */
35 #define SINGLE_Ebias 127
36 #define SINGLE_Emin (-126) /* smallest valid exponent */
37
38 static u_char normalize_no_excep(FPU_REG *r, int exp, int sign)
39 {
40 u_char tag;
41
42 setexponent16(r, exp);
43
44 tag = FPU_normalize_nuo(r);
45 stdexp(r);
46 if (sign)
47 setnegative(r);
48
49 return tag;
50 }
51
52 int FPU_tagof(FPU_REG *ptr)
53 {
54 int exp;
55
56 exp = exponent16(ptr) & 0x7fff;
57 if (exp == 0) {
58 if (!(ptr->sigh | ptr->sigl)) {
59 return TAG_Zero;
60 }
61 /* The number is a de-normal or pseudodenormal. */
62 return TAG_Special;
63 }
64
65 if (exp == 0x7fff) {
66 /* Is an Infinity, a NaN, or an unsupported data type. */
67 return TAG_Special;
68 }
69
70 if (!(ptr->sigh & 0x80000000)) {
71 /* Unsupported data type. */
72 /* Valid numbers have the ms bit set to 1. */
73 /* Unnormal. */
74 return TAG_Special;
75 }
76
77 return TAG_Valid;
78 }
79
80 /* Get a long double from user memory */
81 int FPU_load_extended(long double __user *s, int stnr)
82 {
83 FPU_REG *sti_ptr = &st(stnr);
84
85 RE_ENTRANT_CHECK_OFF;
86 FPU_access_ok(VERIFY_READ, s, 10);
87 __copy_from_user(sti_ptr, s, 10);
88 RE_ENTRANT_CHECK_ON;
89
90 return FPU_tagof(sti_ptr);
91 }
92
93 /* Get a double from user memory */
94 int FPU_load_double(double __user *dfloat, FPU_REG *loaded_data)
95 {
96 int exp, tag, negative;
97 unsigned m64, l64;
98
99 RE_ENTRANT_CHECK_OFF;
100 FPU_access_ok(VERIFY_READ, dfloat, 8);
101 FPU_get_user(m64, 1 + (unsigned long __user *)dfloat);
102 FPU_get_user(l64, (unsigned long __user *)dfloat);
103 RE_ENTRANT_CHECK_ON;
104
105 negative = (m64 & 0x80000000) ? SIGN_Negative : SIGN_Positive;
106 exp = ((m64 & 0x7ff00000) >> 20) - DOUBLE_Ebias + EXTENDED_Ebias;
107 m64 &= 0xfffff;
108 if (exp > DOUBLE_Emax + EXTENDED_Ebias) {
109 /* Infinity or NaN */
110 if ((m64 == 0) && (l64 == 0)) {
111 /* +- infinity */
112 loaded_data->sigh = 0x80000000;
113 loaded_data->sigl = 0x00000000;
114 exp = EXP_Infinity + EXTENDED_Ebias;
115 tag = TAG_Special;
116 } else {
117 /* Must be a signaling or quiet NaN */
118 exp = EXP_NaN + EXTENDED_Ebias;
119 loaded_data->sigh = (m64 << 11) | 0x80000000;
120 loaded_data->sigh |= l64 >> 21;
121 loaded_data->sigl = l64 << 11;
122 tag = TAG_Special; /* The calling function must look for NaNs */
123 }
124 } else if (exp < DOUBLE_Emin + EXTENDED_Ebias) {
125 /* Zero or de-normal */
126 if ((m64 == 0) && (l64 == 0)) {
127 /* Zero */
128 reg_copy(&CONST_Z, loaded_data);
129 exp = 0;
130 tag = TAG_Zero;
131 } else {
132 /* De-normal */
133 loaded_data->sigh = m64 << 11;
134 loaded_data->sigh |= l64 >> 21;
135 loaded_data->sigl = l64 << 11;
136
137 return normalize_no_excep(loaded_data, DOUBLE_Emin,
138 negative)
139 | (denormal_operand() < 0 ? FPU_Exception : 0);
140 }
141 } else {
142 loaded_data->sigh = (m64 << 11) | 0x80000000;
143 loaded_data->sigh |= l64 >> 21;
144 loaded_data->sigl = l64 << 11;
145
146 tag = TAG_Valid;
147 }
148
149 setexponent16(loaded_data, exp | negative);
150
151 return tag;
152 }
153
154 /* Get a float from user memory */
155 int FPU_load_single(float __user *single, FPU_REG *loaded_data)
156 {
157 unsigned m32;
158 int exp, tag, negative;
159
160 RE_ENTRANT_CHECK_OFF;
161 FPU_access_ok(VERIFY_READ, single, 4);
162 FPU_get_user(m32, (unsigned long __user *)single);
163 RE_ENTRANT_CHECK_ON;
164
165 negative = (m32 & 0x80000000) ? SIGN_Negative : SIGN_Positive;
166
167 if (!(m32 & 0x7fffffff)) {
168 /* Zero */
169 reg_copy(&CONST_Z, loaded_data);
170 addexponent(loaded_data, negative);
171 return TAG_Zero;
172 }
173 exp = ((m32 & 0x7f800000) >> 23) - SINGLE_Ebias + EXTENDED_Ebias;
174 m32 = (m32 & 0x7fffff) << 8;
175 if (exp < SINGLE_Emin + EXTENDED_Ebias) {
176 /* De-normals */
177 loaded_data->sigh = m32;
178 loaded_data->sigl = 0;
179
180 return normalize_no_excep(loaded_data, SINGLE_Emin, negative)
181 | (denormal_operand() < 0 ? FPU_Exception : 0);
182 } else if (exp > SINGLE_Emax + EXTENDED_Ebias) {
183 /* Infinity or NaN */
184 if (m32 == 0) {
185 /* +- infinity */
186 loaded_data->sigh = 0x80000000;
187 loaded_data->sigl = 0x00000000;
188 exp = EXP_Infinity + EXTENDED_Ebias;
189 tag = TAG_Special;
190 } else {
191 /* Must be a signaling or quiet NaN */
192 exp = EXP_NaN + EXTENDED_Ebias;
193 loaded_data->sigh = m32 | 0x80000000;
194 loaded_data->sigl = 0;
195 tag = TAG_Special; /* The calling function must look for NaNs */
196 }
197 } else {
198 loaded_data->sigh = m32 | 0x80000000;
199 loaded_data->sigl = 0;
200 tag = TAG_Valid;
201 }
202
203 setexponent16(loaded_data, exp | negative); /* Set the sign. */
204
205 return tag;
206 }
207
208 /* Get a long long from user memory */
209 int FPU_load_int64(long long __user *_s)
210 {
211 long long s;
212 int sign;
213 FPU_REG *st0_ptr = &st(0);
214
215 RE_ENTRANT_CHECK_OFF;
216 FPU_access_ok(VERIFY_READ, _s, 8);
217 if (copy_from_user(&s, _s, 8))
218 FPU_abort;
219 RE_ENTRANT_CHECK_ON;
220
221 if (s == 0) {
222 reg_copy(&CONST_Z, st0_ptr);
223 return TAG_Zero;
224 }
225
226 if (s > 0)
227 sign = SIGN_Positive;
228 else {
229 s = -s;
230 sign = SIGN_Negative;
231 }
232
233 significand(st0_ptr) = s;
234
235 return normalize_no_excep(st0_ptr, 63, sign);
236 }
237
238 /* Get a long from user memory */
239 int FPU_load_int32(long __user *_s, FPU_REG *loaded_data)
240 {
241 long s;
242 int negative;
243
244 RE_ENTRANT_CHECK_OFF;
245 FPU_access_ok(VERIFY_READ, _s, 4);
246 FPU_get_user(s, _s);
247 RE_ENTRANT_CHECK_ON;
248
249 if (s == 0) {
250 reg_copy(&CONST_Z, loaded_data);
251 return TAG_Zero;
252 }
253
254 if (s > 0)
255 negative = SIGN_Positive;
256 else {
257 s = -s;
258 negative = SIGN_Negative;
259 }
260
261 loaded_data->sigh = s;
262 loaded_data->sigl = 0;
263
264 return normalize_no_excep(loaded_data, 31, negative);
265 }
266
267 /* Get a short from user memory */
268 int FPU_load_int16(short __user *_s, FPU_REG *loaded_data)
269 {
270 int s, negative;
271
272 RE_ENTRANT_CHECK_OFF;
273 FPU_access_ok(VERIFY_READ, _s, 2);
274 /* Cast as short to get the sign extended. */
275 FPU_get_user(s, _s);
276 RE_ENTRANT_CHECK_ON;
277
278 if (s == 0) {
279 reg_copy(&CONST_Z, loaded_data);
280 return TAG_Zero;
281 }
282
283 if (s > 0)
284 negative = SIGN_Positive;
285 else {
286 s = -s;
287 negative = SIGN_Negative;
288 }
289
290 loaded_data->sigh = s << 16;
291 loaded_data->sigl = 0;
292
293 return normalize_no_excep(loaded_data, 15, negative);
294 }
295
296 /* Get a packed bcd array from user memory */
297 int FPU_load_bcd(u_char __user *s)
298 {
299 FPU_REG *st0_ptr = &st(0);
300 int pos;
301 u_char bcd;
302 long long l = 0;
303 int sign;
304
305 RE_ENTRANT_CHECK_OFF;
306 FPU_access_ok(VERIFY_READ, s, 10);
307 RE_ENTRANT_CHECK_ON;
308 for (pos = 8; pos >= 0; pos--) {
309 l *= 10;
310 RE_ENTRANT_CHECK_OFF;
311 FPU_get_user(bcd, s + pos);
312 RE_ENTRANT_CHECK_ON;
313 l += bcd >> 4;
314 l *= 10;
315 l += bcd & 0x0f;
316 }
317
318 RE_ENTRANT_CHECK_OFF;
319 FPU_get_user(sign, s + 9);
320 sign = sign & 0x80 ? SIGN_Negative : SIGN_Positive;
321 RE_ENTRANT_CHECK_ON;
322
323 if (l == 0) {
324 reg_copy(&CONST_Z, st0_ptr);
325 addexponent(st0_ptr, sign); /* Set the sign. */
326 return TAG_Zero;
327 } else {
328 significand(st0_ptr) = l;
329 return normalize_no_excep(st0_ptr, 63, sign);
330 }
331 }
332
333 /*===========================================================================*/
334
335 /* Put a long double into user memory */
336 int FPU_store_extended(FPU_REG *st0_ptr, u_char st0_tag,
337 long double __user * d)
338 {
339 /*
340 The only exception raised by an attempt to store to an
341 extended format is the Invalid Stack exception, i.e.
342 attempting to store from an empty register.
343 */
344
345 if (st0_tag != TAG_Empty) {
346 RE_ENTRANT_CHECK_OFF;
347 FPU_access_ok(VERIFY_WRITE, d, 10);
348
349 FPU_put_user(st0_ptr->sigl, (unsigned long __user *)d);
350 FPU_put_user(st0_ptr->sigh,
351 (unsigned long __user *)((u_char __user *) d + 4));
352 FPU_put_user(exponent16(st0_ptr),
353 (unsigned short __user *)((u_char __user *) d +
354 8));
355 RE_ENTRANT_CHECK_ON;
356
357 return 1;
358 }
359
360 /* Empty register (stack underflow) */
361 EXCEPTION(EX_StackUnder);
362 if (control_word & CW_Invalid) {
363 /* The masked response */
364 /* Put out the QNaN indefinite */
365 RE_ENTRANT_CHECK_OFF;
366 FPU_access_ok(VERIFY_WRITE, d, 10);
367 FPU_put_user(0, (unsigned long __user *)d);
368 FPU_put_user(0xc0000000, 1 + (unsigned long __user *)d);
369 FPU_put_user(0xffff, 4 + (short __user *)d);
370 RE_ENTRANT_CHECK_ON;
371 return 1;
372 } else
373 return 0;
374
375 }
376
377 /* Put a double into user memory */
378 int FPU_store_double(FPU_REG *st0_ptr, u_char st0_tag, double __user *dfloat)
379 {
380 unsigned long l[2];
381 unsigned long increment = 0; /* avoid gcc warnings */
382 int precision_loss;
383 int exp;
384 FPU_REG tmp;
385
386 if (st0_tag == TAG_Valid) {
387 reg_copy(st0_ptr, &tmp);
388 exp = exponent(&tmp);
389
390 if (exp < DOUBLE_Emin) { /* It may be a denormal */
391 addexponent(&tmp, -DOUBLE_Emin + 52); /* largest exp to be 51 */
392
393 denormal_arg:
394
395 if ((precision_loss = FPU_round_to_int(&tmp, st0_tag))) {
396 #ifdef PECULIAR_486
397 /* Did it round to a non-denormal ? */
398 /* This behaviour might be regarded as peculiar, it appears
399 that the 80486 rounds to the dest precision, then
400 converts to decide underflow. */
401 if (!
402 ((tmp.sigh == 0x00100000) && (tmp.sigl == 0)
403 && (st0_ptr->sigl & 0x000007ff)))
404 #endif /* PECULIAR_486 */
405 {
406 EXCEPTION(EX_Underflow);
407 /* This is a special case: see sec 16.2.5.1 of
408 the 80486 book */
409 if (!(control_word & CW_Underflow))
410 return 0;
411 }
412 EXCEPTION(precision_loss);
413 if (!(control_word & CW_Precision))
414 return 0;
415 }
416 l[0] = tmp.sigl;
417 l[1] = tmp.sigh;
418 } else {
419 if (tmp.sigl & 0x000007ff) {
420 precision_loss = 1;
421 switch (control_word & CW_RC) {
422 case RC_RND:
423 /* Rounding can get a little messy.. */
424 increment = ((tmp.sigl & 0x7ff) > 0x400) | /* nearest */
425 ((tmp.sigl & 0xc00) == 0xc00); /* odd -> even */
426 break;
427 case RC_DOWN: /* towards -infinity */
428 increment =
429 signpositive(&tmp) ? 0 : tmp.
430 sigl & 0x7ff;
431 break;
432 case RC_UP: /* towards +infinity */
433 increment =
434 signpositive(&tmp) ? tmp.
435 sigl & 0x7ff : 0;
436 break;
437 case RC_CHOP:
438 increment = 0;
439 break;
440 }
441
442 /* Truncate the mantissa */
443 tmp.sigl &= 0xfffff800;
444
445 if (increment) {
446 if (tmp.sigl >= 0xfffff800) {
447 /* the sigl part overflows */
448 if (tmp.sigh == 0xffffffff) {
449 /* The sigh part overflows */
450 tmp.sigh = 0x80000000;
451 exp++;
452 if (exp >= EXP_OVER)
453 goto overflow;
454 } else {
455 tmp.sigh++;
456 }
457 tmp.sigl = 0x00000000;
458 } else {
459 /* We only need to increment sigl */
460 tmp.sigl += 0x00000800;
461 }
462 }
463 } else
464 precision_loss = 0;
465
466 l[0] = (tmp.sigl >> 11) | (tmp.sigh << 21);
467 l[1] = ((tmp.sigh >> 11) & 0xfffff);
468
469 if (exp > DOUBLE_Emax) {
470 overflow:
471 EXCEPTION(EX_Overflow);
472 if (!(control_word & CW_Overflow))
473 return 0;
474 set_precision_flag_up();
475 if (!(control_word & CW_Precision))
476 return 0;
477
478 /* This is a special case: see sec 16.2.5.1 of the 80486 book */
479 /* Overflow to infinity */
480 l[0] = 0x00000000; /* Set to */
481 l[1] = 0x7ff00000; /* + INF */
482 } else {
483 if (precision_loss) {
484 if (increment)
485 set_precision_flag_up();
486 else
487 set_precision_flag_down();
488 }
489 /* Add the exponent */
490 l[1] |= (((exp + DOUBLE_Ebias) & 0x7ff) << 20);
491 }
492 }
493 } else if (st0_tag == TAG_Zero) {
494 /* Number is zero */
495 l[0] = 0;
496 l[1] = 0;
497 } else if (st0_tag == TAG_Special) {
498 st0_tag = FPU_Special(st0_ptr);
499 if (st0_tag == TW_Denormal) {
500 /* A denormal will always underflow. */
501 #ifndef PECULIAR_486
502 /* An 80486 is supposed to be able to generate
503 a denormal exception here, but... */
504 /* Underflow has priority. */
505 if (control_word & CW_Underflow)
506 denormal_operand();
507 #endif /* PECULIAR_486 */
508 reg_copy(st0_ptr, &tmp);
509 goto denormal_arg;
510 } else if (st0_tag == TW_Infinity) {
511 l[0] = 0;
512 l[1] = 0x7ff00000;
513 } else if (st0_tag == TW_NaN) {
514 /* Is it really a NaN ? */
515 if ((exponent(st0_ptr) == EXP_OVER)
516 && (st0_ptr->sigh & 0x80000000)) {
517 /* See if we can get a valid NaN from the FPU_REG */
518 l[0] =
519 (st0_ptr->sigl >> 11) | (st0_ptr->
520 sigh << 21);
521 l[1] = ((st0_ptr->sigh >> 11) & 0xfffff);
522 if (!(st0_ptr->sigh & 0x40000000)) {
523 /* It is a signalling NaN */
524 EXCEPTION(EX_Invalid);
525 if (!(control_word & CW_Invalid))
526 return 0;
527 l[1] |= (0x40000000 >> 11);
528 }
529 l[1] |= 0x7ff00000;
530 } else {
531 /* It is an unsupported data type */
532 EXCEPTION(EX_Invalid);
533 if (!(control_word & CW_Invalid))
534 return 0;
535 l[0] = 0;
536 l[1] = 0xfff80000;
537 }
538 }
539 } else if (st0_tag == TAG_Empty) {
540 /* Empty register (stack underflow) */
541 EXCEPTION(EX_StackUnder);
542 if (control_word & CW_Invalid) {
543 /* The masked response */
544 /* Put out the QNaN indefinite */
545 RE_ENTRANT_CHECK_OFF;
546 FPU_access_ok(VERIFY_WRITE, dfloat, 8);
547 FPU_put_user(0, (unsigned long __user *)dfloat);
548 FPU_put_user(0xfff80000,
549 1 + (unsigned long __user *)dfloat);
550 RE_ENTRANT_CHECK_ON;
551 return 1;
552 } else
553 return 0;
554 }
555 if (getsign(st0_ptr))
556 l[1] |= 0x80000000;
557
558 RE_ENTRANT_CHECK_OFF;
559 FPU_access_ok(VERIFY_WRITE, dfloat, 8);
560 FPU_put_user(l[0], (unsigned long __user *)dfloat);
561 FPU_put_user(l[1], 1 + (unsigned long __user *)dfloat);
562 RE_ENTRANT_CHECK_ON;
563
564 return 1;
565 }
566
567 /* Put a float into user memory */
568 int FPU_store_single(FPU_REG *st0_ptr, u_char st0_tag, float __user *single)
569 {
570 long templ = 0;
571 unsigned long increment = 0; /* avoid gcc warnings */
572 int precision_loss;
573 int exp;
574 FPU_REG tmp;
575
576 if (st0_tag == TAG_Valid) {
577
578 reg_copy(st0_ptr, &tmp);
579 exp = exponent(&tmp);
580
581 if (exp < SINGLE_Emin) {
582 addexponent(&tmp, -SINGLE_Emin + 23); /* largest exp to be 22 */
583
584 denormal_arg:
585
586 if ((precision_loss = FPU_round_to_int(&tmp, st0_tag))) {
587 #ifdef PECULIAR_486
588 /* Did it round to a non-denormal ? */
589 /* This behaviour might be regarded as peculiar, it appears
590 that the 80486 rounds to the dest precision, then
591 converts to decide underflow. */
592 if (!((tmp.sigl == 0x00800000) &&
593 ((st0_ptr->sigh & 0x000000ff)
594 || st0_ptr->sigl)))
595 #endif /* PECULIAR_486 */
596 {
597 EXCEPTION(EX_Underflow);
598 /* This is a special case: see sec 16.2.5.1 of
599 the 80486 book */
600 if (!(control_word & CW_Underflow))
601 return 0;
602 }
603 EXCEPTION(precision_loss);
604 if (!(control_word & CW_Precision))
605 return 0;
606 }
607 templ = tmp.sigl;
608 } else {
609 if (tmp.sigl | (tmp.sigh & 0x000000ff)) {
610 unsigned long sigh = tmp.sigh;
611 unsigned long sigl = tmp.sigl;
612
613 precision_loss = 1;
614 switch (control_word & CW_RC) {
615 case RC_RND:
616 increment = ((sigh & 0xff) > 0x80) /* more than half */
617 ||(((sigh & 0xff) == 0x80) && sigl) /* more than half */
618 ||((sigh & 0x180) == 0x180); /* round to even */
619 break;
620 case RC_DOWN: /* towards -infinity */
621 increment = signpositive(&tmp)
622 ? 0 : (sigl | (sigh & 0xff));
623 break;
624 case RC_UP: /* towards +infinity */
625 increment = signpositive(&tmp)
626 ? (sigl | (sigh & 0xff)) : 0;
627 break;
628 case RC_CHOP:
629 increment = 0;
630 break;
631 }
632
633 /* Truncate part of the mantissa */
634 tmp.sigl = 0;
635
636 if (increment) {
637 if (sigh >= 0xffffff00) {
638 /* The sigh part overflows */
639 tmp.sigh = 0x80000000;
640 exp++;
641 if (exp >= EXP_OVER)
642 goto overflow;
643 } else {
644 tmp.sigh &= 0xffffff00;
645 tmp.sigh += 0x100;
646 }
647 } else {
648 tmp.sigh &= 0xffffff00; /* Finish the truncation */
649 }
650 } else
651 precision_loss = 0;
652
653 templ = (tmp.sigh >> 8) & 0x007fffff;
654
655 if (exp > SINGLE_Emax) {
656 overflow:
657 EXCEPTION(EX_Overflow);
658 if (!(control_word & CW_Overflow))
659 return 0;
660 set_precision_flag_up();
661 if (!(control_word & CW_Precision))
662 return 0;
663
664 /* This is a special case: see sec 16.2.5.1 of the 80486 book. */
665 /* Masked response is overflow to infinity. */
666 templ = 0x7f800000;
667 } else {
668 if (precision_loss) {
669 if (increment)
670 set_precision_flag_up();
671 else
672 set_precision_flag_down();
673 }
674 /* Add the exponent */
675 templ |= ((exp + SINGLE_Ebias) & 0xff) << 23;
676 }
677 }
678 } else if (st0_tag == TAG_Zero) {
679 templ = 0;
680 } else if (st0_tag == TAG_Special) {
681 st0_tag = FPU_Special(st0_ptr);
682 if (st0_tag == TW_Denormal) {
683 reg_copy(st0_ptr, &tmp);
684
685 /* A denormal will always underflow. */
686 #ifndef PECULIAR_486
687 /* An 80486 is supposed to be able to generate
688 a denormal exception here, but... */
689 /* Underflow has priority. */
690 if (control_word & CW_Underflow)
691 denormal_operand();
692 #endif /* PECULIAR_486 */
693 goto denormal_arg;
694 } else if (st0_tag == TW_Infinity) {
695 templ = 0x7f800000;
696 } else if (st0_tag == TW_NaN) {
697 /* Is it really a NaN ? */
698 if ((exponent(st0_ptr) == EXP_OVER)
699 && (st0_ptr->sigh & 0x80000000)) {
700 /* See if we can get a valid NaN from the FPU_REG */
701 templ = st0_ptr->sigh >> 8;
702 if (!(st0_ptr->sigh & 0x40000000)) {
703 /* It is a signalling NaN */
704 EXCEPTION(EX_Invalid);
705 if (!(control_word & CW_Invalid))
706 return 0;
707 templ |= (0x40000000 >> 8);
708 }
709 templ |= 0x7f800000;
710 } else {
711 /* It is an unsupported data type */
712 EXCEPTION(EX_Invalid);
713 if (!(control_word & CW_Invalid))
714 return 0;
715 templ = 0xffc00000;
716 }
717 }
718 #ifdef PARANOID
719 else {
720 EXCEPTION(EX_INTERNAL | 0x164);
721 return 0;
722 }
723 #endif
724 } else if (st0_tag == TAG_Empty) {
725 /* Empty register (stack underflow) */
726 EXCEPTION(EX_StackUnder);
727 if (control_word & EX_Invalid) {
728 /* The masked response */
729 /* Put out the QNaN indefinite */
730 RE_ENTRANT_CHECK_OFF;
731 FPU_access_ok(VERIFY_WRITE, single, 4);
732 FPU_put_user(0xffc00000,
733 (unsigned long __user *)single);
734 RE_ENTRANT_CHECK_ON;
735 return 1;
736 } else
737 return 0;
738 }
739 #ifdef PARANOID
740 else {
741 EXCEPTION(EX_INTERNAL | 0x163);
742 return 0;
743 }
744 #endif
745 if (getsign(st0_ptr))
746 templ |= 0x80000000;
747
748 RE_ENTRANT_CHECK_OFF;
749 FPU_access_ok(VERIFY_WRITE, single, 4);
750 FPU_put_user(templ, (unsigned long __user *)single);
751 RE_ENTRANT_CHECK_ON;
752
753 return 1;
754 }
755
756 /* Put a long long into user memory */
757 int FPU_store_int64(FPU_REG *st0_ptr, u_char st0_tag, long long __user *d)
758 {
759 FPU_REG t;
760 long long tll;
761 int precision_loss;
762
763 if (st0_tag == TAG_Empty) {
764 /* Empty register (stack underflow) */
765 EXCEPTION(EX_StackUnder);
766 goto invalid_operand;
767 } else if (st0_tag == TAG_Special) {
768 st0_tag = FPU_Special(st0_ptr);
769 if ((st0_tag == TW_Infinity) || (st0_tag == TW_NaN)) {
770 EXCEPTION(EX_Invalid);
771 goto invalid_operand;
772 }
773 }
774
775 reg_copy(st0_ptr, &t);
776 precision_loss = FPU_round_to_int(&t, st0_tag);
777 ((long *)&tll)[0] = t.sigl;
778 ((long *)&tll)[1] = t.sigh;
779 if ((precision_loss == 1) ||
780 ((t.sigh & 0x80000000) &&
781 !((t.sigh == 0x80000000) && (t.sigl == 0) && signnegative(&t)))) {
782 EXCEPTION(EX_Invalid);
783 /* This is a special case: see sec 16.2.5.1 of the 80486 book */
784 invalid_operand:
785 if (control_word & EX_Invalid) {
786 /* Produce something like QNaN "indefinite" */
787 tll = 0x8000000000000000LL;
788 } else
789 return 0;
790 } else {
791 if (precision_loss)
792 set_precision_flag(precision_loss);
793 if (signnegative(&t))
794 tll = -tll;
795 }
796
797 RE_ENTRANT_CHECK_OFF;
798 FPU_access_ok(VERIFY_WRITE, d, 8);
799 if (copy_to_user(d, &tll, 8))
800 FPU_abort;
801 RE_ENTRANT_CHECK_ON;
802
803 return 1;
804 }
805
806 /* Put a long into user memory */
807 int FPU_store_int32(FPU_REG *st0_ptr, u_char st0_tag, long __user *d)
808 {
809 FPU_REG t;
810 int precision_loss;
811
812 if (st0_tag == TAG_Empty) {
813 /* Empty register (stack underflow) */
814 EXCEPTION(EX_StackUnder);
815 goto invalid_operand;
816 } else if (st0_tag == TAG_Special) {
817 st0_tag = FPU_Special(st0_ptr);
818 if ((st0_tag == TW_Infinity) || (st0_tag == TW_NaN)) {
819 EXCEPTION(EX_Invalid);
820 goto invalid_operand;
821 }
822 }
823
824 reg_copy(st0_ptr, &t);
825 precision_loss = FPU_round_to_int(&t, st0_tag);
826 if (t.sigh ||
827 ((t.sigl & 0x80000000) &&
828 !((t.sigl == 0x80000000) && signnegative(&t)))) {
829 EXCEPTION(EX_Invalid);
830 /* This is a special case: see sec 16.2.5.1 of the 80486 book */
831 invalid_operand:
832 if (control_word & EX_Invalid) {
833 /* Produce something like QNaN "indefinite" */
834 t.sigl = 0x80000000;
835 } else
836 return 0;
837 } else {
838 if (precision_loss)
839 set_precision_flag(precision_loss);
840 if (signnegative(&t))
841 t.sigl = -(long)t.sigl;
842 }
843
844 RE_ENTRANT_CHECK_OFF;
845 FPU_access_ok(VERIFY_WRITE, d, 4);
846 FPU_put_user(t.sigl, (unsigned long __user *)d);
847 RE_ENTRANT_CHECK_ON;
848
849 return 1;
850 }
851
852 /* Put a short into user memory */
853 int FPU_store_int16(FPU_REG *st0_ptr, u_char st0_tag, short __user *d)
854 {
855 FPU_REG t;
856 int precision_loss;
857
858 if (st0_tag == TAG_Empty) {
859 /* Empty register (stack underflow) */
860 EXCEPTION(EX_StackUnder);
861 goto invalid_operand;
862 } else if (st0_tag == TAG_Special) {
863 st0_tag = FPU_Special(st0_ptr);
864 if ((st0_tag == TW_Infinity) || (st0_tag == TW_NaN)) {
865 EXCEPTION(EX_Invalid);
866 goto invalid_operand;
867 }
868 }
869
870 reg_copy(st0_ptr, &t);
871 precision_loss = FPU_round_to_int(&t, st0_tag);
872 if (t.sigh ||
873 ((t.sigl & 0xffff8000) &&
874 !((t.sigl == 0x8000) && signnegative(&t)))) {
875 EXCEPTION(EX_Invalid);
876 /* This is a special case: see sec 16.2.5.1 of the 80486 book */
877 invalid_operand:
878 if (control_word & EX_Invalid) {
879 /* Produce something like QNaN "indefinite" */
880 t.sigl = 0x8000;
881 } else
882 return 0;
883 } else {
884 if (precision_loss)
885 set_precision_flag(precision_loss);
886 if (signnegative(&t))
887 t.sigl = -t.sigl;
888 }
889
890 RE_ENTRANT_CHECK_OFF;
891 FPU_access_ok(VERIFY_WRITE, d, 2);
892 FPU_put_user((short)t.sigl, d);
893 RE_ENTRANT_CHECK_ON;
894
895 return 1;
896 }
897
898 /* Put a packed bcd array into user memory */
899 int FPU_store_bcd(FPU_REG *st0_ptr, u_char st0_tag, u_char __user *d)
900 {
901 FPU_REG t;
902 unsigned long long ll;
903 u_char b;
904 int i, precision_loss;
905 u_char sign = (getsign(st0_ptr) == SIGN_NEG) ? 0x80 : 0;
906
907 if (st0_tag == TAG_Empty) {
908 /* Empty register (stack underflow) */
909 EXCEPTION(EX_StackUnder);
910 goto invalid_operand;
911 } else if (st0_tag == TAG_Special) {
912 st0_tag = FPU_Special(st0_ptr);
913 if ((st0_tag == TW_Infinity) || (st0_tag == TW_NaN)) {
914 EXCEPTION(EX_Invalid);
915 goto invalid_operand;
916 }
917 }
918
919 reg_copy(st0_ptr, &t);
920 precision_loss = FPU_round_to_int(&t, st0_tag);
921 ll = significand(&t);
922
923 /* Check for overflow, by comparing with 999999999999999999 decimal. */
924 if ((t.sigh > 0x0de0b6b3) ||
925 ((t.sigh == 0x0de0b6b3) && (t.sigl > 0xa763ffff))) {
926 EXCEPTION(EX_Invalid);
927 /* This is a special case: see sec 16.2.5.1 of the 80486 book */
928 invalid_operand:
929 if (control_word & CW_Invalid) {
930 /* Produce the QNaN "indefinite" */
931 RE_ENTRANT_CHECK_OFF;
932 FPU_access_ok(VERIFY_WRITE, d, 10);
933 for (i = 0; i < 7; i++)
934 FPU_put_user(0, d + i); /* These bytes "undefined" */
935 FPU_put_user(0xc0, d + 7); /* This byte "undefined" */
936 FPU_put_user(0xff, d + 8);
937 FPU_put_user(0xff, d + 9);
938 RE_ENTRANT_CHECK_ON;
939 return 1;
940 } else
941 return 0;
942 } else if (precision_loss) {
943 /* Precision loss doesn't stop the data transfer */
944 set_precision_flag(precision_loss);
945 }
946
947 RE_ENTRANT_CHECK_OFF;
948 FPU_access_ok(VERIFY_WRITE, d, 10);
949 RE_ENTRANT_CHECK_ON;
950 for (i = 0; i < 9; i++) {
951 b = FPU_div_small(&ll, 10);
952 b |= (FPU_div_small(&ll, 10)) << 4;
953 RE_ENTRANT_CHECK_OFF;
954 FPU_put_user(b, d + i);
955 RE_ENTRANT_CHECK_ON;
956 }
957 RE_ENTRANT_CHECK_OFF;
958 FPU_put_user(sign, d + 9);
959 RE_ENTRANT_CHECK_ON;
960
961 return 1;
962 }
963
964 /*===========================================================================*/
965
966 /* r gets mangled such that sig is int, sign:
967 it is NOT normalized */
968 /* The return value (in eax) is zero if the result is exact,
969 if bits are changed due to rounding, truncation, etc, then
970 a non-zero value is returned */
971 /* Overflow is signalled by a non-zero return value (in eax).
972 In the case of overflow, the returned significand always has the
973 largest possible value */
974 int FPU_round_to_int(FPU_REG *r, u_char tag)
975 {
976 u_char very_big;
977 unsigned eax;
978
979 if (tag == TAG_Zero) {
980 /* Make sure that zero is returned */
981 significand(r) = 0;
982 return 0; /* o.k. */
983 }
984
985 if (exponent(r) > 63) {
986 r->sigl = r->sigh = ~0; /* The largest representable number */
987 return 1; /* overflow */
988 }
989
990 eax = FPU_shrxs(&r->sigl, 63 - exponent(r));
991 very_big = !(~(r->sigh) | ~(r->sigl)); /* test for 0xfff...fff */
992 #define half_or_more (eax & 0x80000000)
993 #define frac_part (eax)
994 #define more_than_half ((eax & 0x80000001) == 0x80000001)
995 switch (control_word & CW_RC) {
996 case RC_RND:
997 if (more_than_half /* nearest */
998 || (half_or_more && (r->sigl & 1))) { /* odd -> even */
999 if (very_big)
1000 return 1; /* overflow */
1001 significand(r)++;
1002 return PRECISION_LOST_UP;
1003 }
1004 break;
1005 case RC_DOWN:
1006 if (frac_part && getsign(r)) {
1007 if (very_big)
1008 return 1; /* overflow */
1009 significand(r)++;
1010 return PRECISION_LOST_UP;
1011 }
1012 break;
1013 case RC_UP:
1014 if (frac_part && !getsign(r)) {
1015 if (very_big)
1016 return 1; /* overflow */
1017 significand(r)++;
1018 return PRECISION_LOST_UP;
1019 }
1020 break;
1021 case RC_CHOP:
1022 break;
1023 }
1024
1025 return eax ? PRECISION_LOST_DOWN : 0;
1026
1027 }
1028
1029 /*===========================================================================*/
1030
1031 u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user *s)
1032 {
1033 unsigned short tag_word = 0;
1034 u_char tag;
1035 int i;
1036
1037 if ((addr_modes.default_mode == VM86) ||
1038 ((addr_modes.default_mode == PM16)
1039 ^ (addr_modes.override.operand_size == OP_SIZE_PREFIX))) {
1040 RE_ENTRANT_CHECK_OFF;
1041 FPU_access_ok(VERIFY_READ, s, 0x0e);
1042 FPU_get_user(control_word, (unsigned short __user *)s);
1043 FPU_get_user(partial_status, (unsigned short __user *)(s + 2));
1044 FPU_get_user(tag_word, (unsigned short __user *)(s + 4));
1045 FPU_get_user(instruction_address.offset,
1046 (unsigned short __user *)(s + 6));
1047 FPU_get_user(instruction_address.selector,
1048 (unsigned short __user *)(s + 8));
1049 FPU_get_user(operand_address.offset,
1050 (unsigned short __user *)(s + 0x0a));
1051 FPU_get_user(operand_address.selector,
1052 (unsigned short __user *)(s + 0x0c));
1053 RE_ENTRANT_CHECK_ON;
1054 s += 0x0e;
1055 if (addr_modes.default_mode == VM86) {
1056 instruction_address.offset
1057 += (instruction_address.selector & 0xf000) << 4;
1058 operand_address.offset +=
1059 (operand_address.selector & 0xf000) << 4;
1060 }
1061 } else {
1062 RE_ENTRANT_CHECK_OFF;
1063 FPU_access_ok(VERIFY_READ, s, 0x1c);
1064 FPU_get_user(control_word, (unsigned short __user *)s);
1065 FPU_get_user(partial_status, (unsigned short __user *)(s + 4));
1066 FPU_get_user(tag_word, (unsigned short __user *)(s + 8));
1067 FPU_get_user(instruction_address.offset,
1068 (unsigned long __user *)(s + 0x0c));
1069 FPU_get_user(instruction_address.selector,
1070 (unsigned short __user *)(s + 0x10));
1071 FPU_get_user(instruction_address.opcode,
1072 (unsigned short __user *)(s + 0x12));
1073 FPU_get_user(operand_address.offset,
1074 (unsigned long __user *)(s + 0x14));
1075 FPU_get_user(operand_address.selector,
1076 (unsigned long __user *)(s + 0x18));
1077 RE_ENTRANT_CHECK_ON;
1078 s += 0x1c;
1079 }
1080
1081 #ifdef PECULIAR_486
1082 control_word &= ~0xe080;
1083 #endif /* PECULIAR_486 */
1084
1085 top = (partial_status >> SW_Top_Shift) & 7;
1086
1087 if (partial_status & ~control_word & CW_Exceptions)
1088 partial_status |= (SW_Summary | SW_Backward);
1089 else
1090 partial_status &= ~(SW_Summary | SW_Backward);
1091
1092 for (i = 0; i < 8; i++) {
1093 tag = tag_word & 3;
1094 tag_word >>= 2;
1095
1096 if (tag == TAG_Empty)
1097 /* New tag is empty. Accept it */
1098 FPU_settag(i, TAG_Empty);
1099 else if (FPU_gettag(i) == TAG_Empty) {
1100 /* Old tag is empty and new tag is not empty. New tag is determined
1101 by old reg contents */
1102 if (exponent(&fpu_register(i)) == -EXTENDED_Ebias) {
1103 if (!
1104 (fpu_register(i).sigl | fpu_register(i).
1105 sigh))
1106 FPU_settag(i, TAG_Zero);
1107 else
1108 FPU_settag(i, TAG_Special);
1109 } else if (exponent(&fpu_register(i)) ==
1110 0x7fff - EXTENDED_Ebias) {
1111 FPU_settag(i, TAG_Special);
1112 } else if (fpu_register(i).sigh & 0x80000000)
1113 FPU_settag(i, TAG_Valid);
1114 else
1115 FPU_settag(i, TAG_Special); /* An Un-normal */
1116 }
1117 /* Else old tag is not empty and new tag is not empty. Old tag
1118 remains correct */
1119 }
1120
1121 return s;
1122 }
1123
1124 void frstor(fpu_addr_modes addr_modes, u_char __user *data_address)
1125 {
1126 int i, regnr;
1127 u_char __user *s = fldenv(addr_modes, data_address);
1128 int offset = (top & 7) * 10, other = 80 - offset;
1129
1130 /* Copy all registers in stack order. */
1131 RE_ENTRANT_CHECK_OFF;
1132 FPU_access_ok(VERIFY_READ, s, 80);
1133 __copy_from_user(register_base + offset, s, other);
1134 if (offset)
1135 __copy_from_user(register_base, s + other, offset);
1136 RE_ENTRANT_CHECK_ON;
1137
1138 for (i = 0; i < 8; i++) {
1139 regnr = (i + top) & 7;
1140 if (FPU_gettag(regnr) != TAG_Empty)
1141 /* The loaded data over-rides all other cases. */
1142 FPU_settag(regnr, FPU_tagof(&st(i)));
1143 }
1144
1145 }
1146
1147 u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user *d)
1148 {
1149 if ((addr_modes.default_mode == VM86) ||
1150 ((addr_modes.default_mode == PM16)
1151 ^ (addr_modes.override.operand_size == OP_SIZE_PREFIX))) {
1152 RE_ENTRANT_CHECK_OFF;
1153 FPU_access_ok(VERIFY_WRITE, d, 14);
1154 #ifdef PECULIAR_486
1155 FPU_put_user(control_word & ~0xe080, (unsigned long __user *)d);
1156 #else
1157 FPU_put_user(control_word, (unsigned short __user *)d);
1158 #endif /* PECULIAR_486 */
1159 FPU_put_user(status_word(), (unsigned short __user *)(d + 2));
1160 FPU_put_user(fpu_tag_word, (unsigned short __user *)(d + 4));
1161 FPU_put_user(instruction_address.offset,
1162 (unsigned short __user *)(d + 6));
1163 FPU_put_user(operand_address.offset,
1164 (unsigned short __user *)(d + 0x0a));
1165 if (addr_modes.default_mode == VM86) {
1166 FPU_put_user((instruction_address.
1167 offset & 0xf0000) >> 4,
1168 (unsigned short __user *)(d + 8));
1169 FPU_put_user((operand_address.offset & 0xf0000) >> 4,
1170 (unsigned short __user *)(d + 0x0c));
1171 } else {
1172 FPU_put_user(instruction_address.selector,
1173 (unsigned short __user *)(d + 8));
1174 FPU_put_user(operand_address.selector,
1175 (unsigned short __user *)(d + 0x0c));
1176 }
1177 RE_ENTRANT_CHECK_ON;
1178 d += 0x0e;
1179 } else {
1180 RE_ENTRANT_CHECK_OFF;
1181 FPU_access_ok(VERIFY_WRITE, d, 7 * 4);
1182 #ifdef PECULIAR_486
1183 control_word &= ~0xe080;
1184 /* An 80486 sets nearly all of the reserved bits to 1. */
1185 control_word |= 0xffff0040;
1186 partial_status = status_word() | 0xffff0000;
1187 fpu_tag_word |= 0xffff0000;
1188 I387.soft.fcs &= ~0xf8000000;
1189 I387.soft.fos |= 0xffff0000;
1190 #endif /* PECULIAR_486 */
1191 if (__copy_to_user(d, &control_word, 7 * 4))
1192 FPU_abort;
1193 RE_ENTRANT_CHECK_ON;
1194 d += 0x1c;
1195 }
1196
1197 control_word |= CW_Exceptions;
1198 partial_status &= ~(SW_Summary | SW_Backward);
1199
1200 return d;
1201 }
1202
1203 void fsave(fpu_addr_modes addr_modes, u_char __user *data_address)
1204 {
1205 u_char __user *d;
1206 int offset = (top & 7) * 10, other = 80 - offset;
1207
1208 d = fstenv(addr_modes, data_address);
1209
1210 RE_ENTRANT_CHECK_OFF;
1211 FPU_access_ok(VERIFY_WRITE, d, 80);
1212
1213 /* Copy all registers in stack order. */
1214 if (__copy_to_user(d, register_base + offset, other))
1215 FPU_abort;
1216 if (offset)
1217 if (__copy_to_user(d + other, register_base, offset))
1218 FPU_abort;
1219 RE_ENTRANT_CHECK_ON;
1220
1221 finit();
1222 }
1223
1224 /*===========================================================================*/
Linux kernel - Deliverables
This page took 0.064674 seconds and 6 git commands to generate.