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/*===========================================================================*/