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