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 
normalize_no_excep(FPU_REG * r,int exp,int sign)39 static 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 
FPU_tagof(FPU_REG * ptr)53 int 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 */
FPU_load_extended(long double __user * s,int stnr)82 int 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 */
FPU_load_double(double __user * dfloat,FPU_REG * loaded_data)95 int 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 */
FPU_load_single(float __user * single,FPU_REG * loaded_data)156 int 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 */
FPU_load_int64(long long __user * _s)210 int 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 */
FPU_load_int32(long __user * _s,FPU_REG * loaded_data)240 int 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 */
FPU_load_int16(short __user * _s,FPU_REG * loaded_data)269 int 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 */
FPU_load_bcd(u_char __user * s)298 int 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 */
FPU_store_extended(FPU_REG * st0_ptr,u_char st0_tag,long double __user * d)337 int 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 */
FPU_store_double(FPU_REG * st0_ptr,u_char st0_tag,double __user * dfloat)379 int 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 */
395 denormal_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 */
FPU_store_single(FPU_REG * st0_ptr,u_char st0_tag,float __user * single)564 int 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 */
FPU_store_int64(FPU_REG * st0_ptr,u_char st0_tag,long long __user * d)753 int 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 */
FPU_store_int32(FPU_REG * st0_ptr,u_char st0_tag,long __user * d)803 int 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 */
FPU_store_int16(FPU_REG * st0_ptr,u_char st0_tag,short __user * d)849 int 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 */
FPU_store_bcd(FPU_REG * st0_ptr,u_char st0_tag,u_char __user * d)895 int 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 */
FPU_round_to_int(FPU_REG * r,u_char tag)970 int 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 
fldenv(fpu_addr_modes addr_modes,u_char __user * s)1027 u_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 
FPU_frstor(fpu_addr_modes addr_modes,u_char __user * data_address)1120 void 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 
fstenv(fpu_addr_modes addr_modes,u_char __user * d)1143 u_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 
fsave(fpu_addr_modes addr_modes,u_char __user * data_address)1199 void 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 /*===========================================================================*/
1221