![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reg_ld_str.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / emulator|
Return to reg_ld_str.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / emulator |
1.1 ! root 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 W. Metzenthen, 22 Parker St, Ormond, Vic 3163, | ! 7: | Australia. E-mail [email protected] | ! 8: | | ! 9: | | ! 10: +---------------------------------------------------------------------------*/ ! 11: ! 12: /*---------------------------------------------------------------------------+ ! 13: | Note: | ! 14: | The file contains code which accesses user memory. | ! 15: | Emulator static data may change when user memory is accessed, due to | ! 16: | other processes using the emulator while swapping is in progress. | ! 17: +---------------------------------------------------------------------------*/ ! 18: ! 19: #include <asm/segment.h> ! 20: ! 21: #include "fpu_system.h" ! 22: #include "exception.h" ! 23: #include "reg_constant.h" ! 24: #include "fpu_emu.h" ! 25: #include "control_w.h" ! 26: #include "status_w.h" ! 27: ! 28: #define EXTENDED_Emax 0x3fff /* largest valid exponent */ ! 29: #define EXTENDED_Ebias 0x3fff ! 30: #define EXTENDED_Emin (-0x3ffe) /* smallest valid exponent */ ! 31: ! 32: #define DOUBLE_Emax 1023 /* largest valid exponent */ ! 33: #define DOUBLE_Ebias 1023 ! 34: #define DOUBLE_Emin (-1022) /* smallest valid exponent */ ! 35: ! 36: #define SINGLE_Emax 127 /* largest valid exponent */ ! 37: #define SINGLE_Ebias 127 ! 38: #define SINGLE_Emin (-126) /* smallest valid exponent */ ! 39: ! 40: ! 41: FPU_REG FPU_loaded_data; ! 42: ! 43: ! 44: /* Get a long double from user memory */ ! 45: void reg_load_extended(void) ! 46: { ! 47: long double *s = (long double *)FPU_data_address; ! 48: unsigned long sigl, sigh, exp; ! 49: ! 50: RE_ENTRANT_CHECK_OFF ! 51: /* Use temporary variables here because FPU_loaded data is ! 52: static and hence re-entrancy problems can arise */ ! 53: sigl = get_fs_long((unsigned long *) s); ! 54: sigh = get_fs_long(1 + (unsigned long *) s); ! 55: exp = get_fs_word(4 + (unsigned short *) s); ! 56: RE_ENTRANT_CHECK_ON ! 57: ! 58: FPU_loaded_data.sigl = sigl; ! 59: FPU_loaded_data.sigh = sigh; ! 60: FPU_loaded_data.exp = exp; ! 61: ! 62: if (FPU_loaded_data.exp & 0x8000) ! 63: FPU_loaded_data.sign = SIGN_NEG; ! 64: else ! 65: FPU_loaded_data.sign = SIGN_POS; ! 66: if ( (FPU_loaded_data.exp &= 0x7fff) == 0 ) ! 67: { ! 68: if ( !(FPU_loaded_data.sigl | FPU_loaded_data.sigh) ) ! 69: { ! 70: FPU_loaded_data.tag = TW_Zero; ! 71: return; ! 72: } ! 73: /* The number is de-normal */ ! 74: /* The default behaviour will take care of this */ ! 75: } ! 76: else if ( FPU_loaded_data.exp == 0x7fff ) ! 77: { ! 78: FPU_loaded_data.exp = EXTENDED_Emax; ! 79: if ( (FPU_loaded_data.sigh == 0x80000000) ! 80: && (FPU_loaded_data.sigl == 0) ) ! 81: { ! 82: FPU_loaded_data.tag = TW_Infinity; ! 83: return; ! 84: } ! 85: if ( !(FPU_loaded_data.sigh & 0x80000000) ) ! 86: { ! 87: /* Unsupported data type */ ! 88: EXCEPTION(EX_Invalid); ! 89: FPU_loaded_data.tag = TW_NaN; ! 90: return; ! 91: } ! 92: FPU_loaded_data.tag = TW_NaN; ! 93: return; ! 94: } ! 95: FPU_loaded_data.exp = (FPU_loaded_data.exp & 0x7fff) - EXTENDED_Ebias ! 96: + EXP_BIAS; ! 97: FPU_loaded_data.tag = TW_Valid; ! 98: ! 99: normalize(&FPU_loaded_data); ! 100: } ! 101: ! 102: ! 103: /* Get a double from user memory */ ! 104: void reg_load_double(void) ! 105: { ! 106: double *dfloat = (double *)FPU_data_address; ! 107: int exp; ! 108: unsigned m64, l64; ! 109: ! 110: RE_ENTRANT_CHECK_OFF ! 111: m64 = get_fs_long(1 + (unsigned long *) dfloat); ! 112: l64 = get_fs_long((unsigned long *) dfloat); ! 113: RE_ENTRANT_CHECK_ON ! 114: ! 115: if (m64 & 0x80000000) ! 116: FPU_loaded_data.sign = SIGN_NEG; ! 117: else ! 118: FPU_loaded_data.sign = SIGN_POS; ! 119: exp = ((m64 & 0x7ff00000) >> 20) - DOUBLE_Ebias; ! 120: m64 &= 0xfffff; ! 121: if (exp > DOUBLE_Emax) ! 122: { ! 123: /* Infinity or NaN */ ! 124: if ((m64 == 0) && (l64 == 0)) ! 125: { ! 126: /* +- infinity */ ! 127: FPU_loaded_data.exp = EXTENDED_Emax; ! 128: FPU_loaded_data.tag = TW_Infinity; ! 129: return; ! 130: } ! 131: else ! 132: { ! 133: /* Must be a signaling or quiet NaN */ ! 134: FPU_loaded_data.exp = EXTENDED_Emax; ! 135: FPU_loaded_data.tag = TW_NaN; ! 136: FPU_loaded_data.sigh = (m64 << 11) | 0x80000000; ! 137: FPU_loaded_data.sigh |= l64 >> 21; ! 138: FPU_loaded_data.sigl = l64 << 11; ! 139: return; ! 140: } ! 141: } ! 142: else if ( exp < DOUBLE_Emin ) ! 143: { ! 144: /* Zero or de-normal */ ! 145: if ((m64 == 0) && (l64 == 0)) ! 146: { ! 147: /* Zero */ ! 148: int c = FPU_loaded_data.sign; ! 149: reg_move(&CONST_Z, &FPU_loaded_data); ! 150: FPU_loaded_data.sign = c; ! 151: return; ! 152: } ! 153: else ! 154: { ! 155: /* De-normal */ ! 156: FPU_loaded_data.exp = DOUBLE_Emin + EXP_BIAS; ! 157: FPU_loaded_data.tag = TW_Valid; ! 158: FPU_loaded_data.sigh = m64 << 11; ! 159: FPU_loaded_data.sigh |= l64 >> 21; ! 160: FPU_loaded_data.sigl = l64 << 11; ! 161: normalize(&FPU_loaded_data); ! 162: return; ! 163: } ! 164: } ! 165: else ! 166: { ! 167: FPU_loaded_data.exp = exp + EXP_BIAS; ! 168: FPU_loaded_data.tag = TW_Valid; ! 169: FPU_loaded_data.sigh = (m64 << 11) | 0x80000000; ! 170: FPU_loaded_data.sigh |= l64 >> 21; ! 171: FPU_loaded_data.sigl = l64 << 11; ! 172: ! 173: return; ! 174: } ! 175: } ! 176: ! 177: ! 178: /* Get a float from user memory */ ! 179: void reg_load_single(void) ! 180: { ! 181: float *single = (float *)FPU_data_address; ! 182: unsigned m32; ! 183: int exp; ! 184: ! 185: RE_ENTRANT_CHECK_OFF ! 186: m32 = get_fs_long((unsigned long *) single); ! 187: RE_ENTRANT_CHECK_ON ! 188: ! 189: if (m32 & 0x80000000) ! 190: FPU_loaded_data.sign = SIGN_NEG; ! 191: else ! 192: FPU_loaded_data.sign = SIGN_POS; ! 193: if (!(m32 & 0x7fffffff)) ! 194: { ! 195: /* Zero */ ! 196: int c = FPU_loaded_data.sign; ! 197: reg_move(&CONST_Z, &FPU_loaded_data); ! 198: FPU_loaded_data.sign = c; ! 199: return; ! 200: } ! 201: exp = ((m32 & 0x7f800000) >> 23) - SINGLE_Ebias; ! 202: m32 = (m32 & 0x7fffff) << 8; ! 203: if ( exp < SINGLE_Emin ) ! 204: { ! 205: /* De-normals */ ! 206: FPU_loaded_data.exp = SINGLE_Emin + EXP_BIAS; ! 207: FPU_loaded_data.tag = TW_Valid; ! 208: FPU_loaded_data.sigh = m32; ! 209: FPU_loaded_data.sigl = 0; ! 210: normalize(&FPU_loaded_data); ! 211: return; ! 212: } ! 213: else if ( exp > SINGLE_Emax ) ! 214: { ! 215: /* Infinity or NaN */ ! 216: if ( m32 == 0 ) ! 217: { ! 218: /* +- infinity */ ! 219: FPU_loaded_data.exp = EXTENDED_Emax; ! 220: FPU_loaded_data.tag = TW_Infinity; ! 221: return; ! 222: } ! 223: else ! 224: { ! 225: /* Must be a signaling or quiet NaN */ ! 226: FPU_loaded_data.exp = EXTENDED_Emax; ! 227: FPU_loaded_data.tag = TW_NaN; ! 228: FPU_loaded_data.sigh = m32 | 0x80000000; ! 229: FPU_loaded_data.sigl = 0; ! 230: return; ! 231: } ! 232: } ! 233: else ! 234: { ! 235: FPU_loaded_data.exp = exp + EXP_BIAS; ! 236: FPU_loaded_data.sigh = m32 | 0x80000000; ! 237: FPU_loaded_data.sigl = 0; ! 238: FPU_loaded_data.tag = TW_Valid; ! 239: } ! 240: } ! 241: ! 242: ! 243: /* Get a long long from user memory */ ! 244: void reg_load_int64(void) ! 245: { ! 246: long long *_s = (long long *)FPU_data_address; ! 247: int e; ! 248: long long s; ! 249: ! 250: RE_ENTRANT_CHECK_OFF ! 251: ((unsigned long *)&s)[0] = get_fs_long((unsigned long *) _s); ! 252: ((unsigned long *)&s)[1] = get_fs_long(1 + (unsigned long *) _s); ! 253: RE_ENTRANT_CHECK_ON ! 254: ! 255: if (s == 0) ! 256: { reg_move(&CONST_Z, &FPU_loaded_data); return; } ! 257: ! 258: if (s > 0) ! 259: FPU_loaded_data.sign = SIGN_POS; ! 260: else ! 261: { ! 262: s = -s; ! 263: FPU_loaded_data.sign = SIGN_NEG; ! 264: } ! 265: ! 266: e = EXP_BIAS + 63; ! 267: *((long long *)&FPU_loaded_data.sigl) = s; ! 268: FPU_loaded_data.exp = e; ! 269: FPU_loaded_data.tag = TW_Valid; ! 270: normalize(&FPU_loaded_data); ! 271: } ! 272: ! 273: ! 274: /* Get a long from user memory */ ! 275: void reg_load_int32(void) ! 276: { ! 277: long *_s = (long *)FPU_data_address; ! 278: long s; ! 279: int e; ! 280: ! 281: RE_ENTRANT_CHECK_OFF ! 282: s = (long)get_fs_long((unsigned long *) _s); ! 283: RE_ENTRANT_CHECK_ON ! 284: ! 285: if (s == 0) ! 286: { reg_move(&CONST_Z, &FPU_loaded_data); return; } ! 287: ! 288: if (s > 0) ! 289: FPU_loaded_data.sign = SIGN_POS; ! 290: else ! 291: { ! 292: s = -s; ! 293: FPU_loaded_data.sign = SIGN_NEG; ! 294: } ! 295: ! 296: e = EXP_BIAS + 31; ! 297: FPU_loaded_data.sigh = s; ! 298: FPU_loaded_data.sigl = 0; ! 299: FPU_loaded_data.exp = e; ! 300: FPU_loaded_data.tag = TW_Valid; ! 301: normalize(&FPU_loaded_data); ! 302: } ! 303: ! 304: ! 305: /* Get a short from user memory */ ! 306: void reg_load_int16(void) ! 307: { ! 308: short *_s = (short *)FPU_data_address; ! 309: long s; ! 310: int e; ! 311: ! 312: RE_ENTRANT_CHECK_OFF ! 313: s = (int)get_fs_word((unsigned short *) _s); ! 314: RE_ENTRANT_CHECK_ON ! 315: ! 316: if (s == 0) ! 317: { reg_move(&CONST_Z, &FPU_loaded_data); return; } ! 318: ! 319: if (s > 0) ! 320: FPU_loaded_data.sign = SIGN_POS; ! 321: else ! 322: { ! 323: s = -s; ! 324: FPU_loaded_data.sign = SIGN_NEG; ! 325: } ! 326: ! 327: e = EXP_BIAS + 31; ! 328: FPU_loaded_data.sigh = s; ! 329: FPU_loaded_data.sigl = 0; ! 330: FPU_loaded_data.exp = e; ! 331: FPU_loaded_data.tag = TW_Valid; ! 332: normalize(&FPU_loaded_data); ! 333: } ! 334: ! 335: ! 336: /* Get a packed bcd array from user memory */ ! 337: void reg_load_bcd(void) ! 338: { ! 339: char *s = (char *)FPU_data_address; ! 340: int pos; ! 341: unsigned char bcd; ! 342: long long l=0; ! 343: ! 344: for ( pos = 8; pos >= 0; pos--) ! 345: { ! 346: l *= 10; ! 347: RE_ENTRANT_CHECK_OFF ! 348: bcd = (unsigned char)get_fs_byte((unsigned char *) s+pos); ! 349: RE_ENTRANT_CHECK_ON ! 350: l += bcd >> 4; ! 351: l *= 10; ! 352: l += bcd & 0x0f; ! 353: } ! 354: ! 355: /* Finish all access to user memory before putting stuff into ! 356: the static FPU_loaded_data */ ! 357: RE_ENTRANT_CHECK_OFF ! 358: FPU_loaded_data.sign = ! 359: ((unsigned char)get_fs_byte((unsigned char *) s+9)) & 0x80 ? ! 360: SIGN_NEG : SIGN_POS; ! 361: RE_ENTRANT_CHECK_ON ! 362: ! 363: if (l == 0) ! 364: { ! 365: char sign = FPU_loaded_data.sign; ! 366: reg_move(&CONST_Z, &FPU_loaded_data); ! 367: FPU_loaded_data.sign = sign; ! 368: } ! 369: else ! 370: { ! 371: *((long long *)&FPU_loaded_data.sigl) = l; ! 372: FPU_loaded_data.exp = EXP_BIAS + 63; ! 373: FPU_loaded_data.tag = TW_Valid; ! 374: normalize(&FPU_loaded_data); ! 375: } ! 376: } ! 377: ! 378: /*===========================================================================*/ ! 379: ! 380: /* Put a long double into user memory */ ! 381: int reg_store_extended(void) ! 382: { ! 383: long double *d = (long double *)FPU_data_address; ! 384: long e = FPU_st0_ptr->exp - EXP_BIAS + EXTENDED_Ebias; ! 385: unsigned short sign = FPU_st0_ptr->sign*0x8000; ! 386: unsigned long ls, ms; ! 387: ! 388: ! 389: if ( FPU_st0_tag == TW_Valid ) ! 390: { ! 391: if ( e >= 0x7fff ) ! 392: { ! 393: EXCEPTION(EX_Overflow); /* Overflow */ ! 394: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 395: if ( control_word & EX_Overflow ) ! 396: { ! 397: /* Overflow to infinity */ ! 398: ls = 0; ! 399: ms = 0x80000000; ! 400: e = 0x7fff; ! 401: } ! 402: else ! 403: return 0; ! 404: } ! 405: else if ( e <= 0 ) ! 406: { ! 407: if ( e == 0 ) ! 408: { ! 409: EXCEPTION(EX_Denormal); /* Pseudo de-normal */ ! 410: ls = FPU_st0_ptr->sigl; ! 411: ms = FPU_st0_ptr->sigh; ! 412: } ! 413: else if ( e > -64 ) ! 414: { ! 415: /* Make a de-normal */ ! 416: FPU_REG tmp; ! 417: EXCEPTION(EX_Denormal); /* De-normal */ ! 418: reg_move(FPU_st0_ptr, &tmp); ! 419: tmp.exp += -EXTENDED_Emin + 64; /* largest exp to be 63 */ ! 420: round_to_int(&tmp); ! 421: e = 0; ! 422: ls = tmp.sigl; ! 423: ms = tmp.sigh; ! 424: } ! 425: else ! 426: { ! 427: EXCEPTION(EX_Underflow); /* Underflow */ ! 428: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 429: if ( control_word & EX_Underflow ) ! 430: { ! 431: /* Underflow to zero */ ! 432: ls = 0; ! 433: ms = 0; ! 434: e = 0; ! 435: } ! 436: else ! 437: return 0; ! 438: } ! 439: } ! 440: else ! 441: { ! 442: ls = FPU_st0_ptr->sigl; ! 443: ms = FPU_st0_ptr->sigh; ! 444: } ! 445: } ! 446: else if ( FPU_st0_tag == TW_Zero ) ! 447: { ! 448: ls = ms = 0; ! 449: e = 0; ! 450: } ! 451: else if ( FPU_st0_tag == TW_Infinity ) ! 452: { ! 453: ls = 0; ! 454: ms = 0x80000000; ! 455: e = 0x7fff; ! 456: } ! 457: else if ( FPU_st0_tag == TW_NaN ) ! 458: { ! 459: ls = FPU_st0_ptr->sigl; ! 460: ms = FPU_st0_ptr->sigh; ! 461: e = 0x7fff; ! 462: } ! 463: else if ( FPU_st0_tag == TW_Empty ) ! 464: { ! 465: /* Empty register (stack underflow) */ ! 466: EXCEPTION(EX_StackUnder); ! 467: if ( control_word & EX_Invalid ) ! 468: { ! 469: /* The masked response */ ! 470: /* Put out the QNaN indefinite */ ! 471: ls = 0; ! 472: ms = 0xc0000000; ! 473: e = 0xffff; ! 474: } ! 475: else ! 476: return 0; ! 477: } ! 478: else ! 479: { ! 480: /* We don't use TW_Denormal yet ... perhaps never! */ ! 481: EXCEPTION(EX_Invalid); ! 482: /* Store a NaN */ ! 483: e = 0x7fff; ! 484: ls = 1; ! 485: ms = 0x80000000; ! 486: } ! 487: RE_ENTRANT_CHECK_OFF ! 488: #ifdef COHERENT ! 489: if (verify_area(d,10)) { ! 490: put_fs_long(ls, (unsigned long *) d); ! 491: put_fs_long(ms, 1 + (unsigned long *) d); ! 492: put_fs_word((unsigned short)e | sign, 4 + (short *) d); ! 493: } ! 494: #else ! 495: verify_area(d,10); ! 496: put_fs_long(ls, (unsigned long *) d); ! 497: put_fs_long(ms, 1 + (unsigned long *) d); ! 498: put_fs_word((unsigned short)e | sign, 4 + (short *) d); ! 499: #endif ! 500: RE_ENTRANT_CHECK_ON ! 501: ! 502: return 1; ! 503: ! 504: } ! 505: ! 506: /* Put a double into user memory */ ! 507: int reg_store_double(void) ! 508: { ! 509: double *dfloat = (double *)FPU_data_address; ! 510: unsigned long l[2]; ! 511: ! 512: ! 513: if (FPU_st0_tag == TW_Valid) ! 514: { ! 515: /* Rounding can get a little messy.. */ ! 516: int exp = FPU_st0_ptr->exp - EXP_BIAS; ! 517: int increment = ((FPU_st0_ptr->sigl & 0x7ff) > 0x400) | /* nearest */ ! 518: ((FPU_st0_ptr->sigl & 0xc00) == 0xc00); /* odd -> even */ ! 519: if ( increment ) ! 520: { ! 521: if ( FPU_st0_ptr->sigl >= 0xfffff800 ) ! 522: { ! 523: /* the sigl part overflows */ ! 524: if ( FPU_st0_ptr->sigh == 0xffffffff ) ! 525: { ! 526: /* The sigh part overflows */ ! 527: l[0] = l[1] = 0; ! 528: exp++; /* no need to check here for overflow */ ! 529: } ! 530: else ! 531: { ! 532: /* No overflow of sigh will happen, can safely increment */ ! 533: l[0] = (FPU_st0_ptr->sigh+1) << 21; ! 534: l[1] = (((FPU_st0_ptr->sigh+1) >> 11) & 0xfffff); ! 535: } ! 536: } ! 537: else ! 538: { ! 539: /* We only need to increment sigl */ ! 540: l[0] = ((FPU_st0_ptr->sigl+0x800) >> 11) | (FPU_st0_ptr->sigh << 21); ! 541: l[1] = ((FPU_st0_ptr->sigh >> 11) & 0xfffff); ! 542: } ! 543: } ! 544: else ! 545: { ! 546: /* No increment required */ ! 547: l[0] = (FPU_st0_ptr->sigl >> 11) | (FPU_st0_ptr->sigh << 21); ! 548: l[1] = ((FPU_st0_ptr->sigh >> 11) & 0xfffff); ! 549: } ! 550: ! 551: if ( exp > DOUBLE_Emax ) ! 552: { ! 553: EXCEPTION(EX_Overflow); ! 554: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 555: if ( control_word & EX_Overflow ) ! 556: { ! 557: /* Overflow to infinity */ ! 558: l[0] = 0x00000000; /* Set to */ ! 559: l[1] = 0x7ff00000; /* + INF */ ! 560: } ! 561: else ! 562: return 0; ! 563: } ! 564: else if ( exp < DOUBLE_Emin ) ! 565: { ! 566: if ( exp > DOUBLE_Emin-53 ) ! 567: { ! 568: /* Make a de-normal */ ! 569: FPU_REG tmp; ! 570: EXCEPTION(EX_Denormal); ! 571: reg_move(FPU_st0_ptr, &tmp); ! 572: tmp.exp += -DOUBLE_Emin + 52; /* largest exp to be 51 */ ! 573: round_to_int(&tmp); ! 574: l[0] = tmp.sigl; ! 575: l[1] = tmp.sigh; ! 576: } ! 577: else ! 578: { ! 579: EXCEPTION(EX_Underflow); ! 580: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 581: if ( control_word & EX_Underflow ) ! 582: { ! 583: /* Underflow to zero */ ! 584: l[0] = l[1] = 0; ! 585: } ! 586: else ! 587: return 0; ! 588: } ! 589: } ! 590: else ! 591: { ! 592: /* Add the exponent */ ! 593: l[1] |= (((exp+DOUBLE_Ebias) & 0x7ff) << 20); ! 594: } ! 595: } ! 596: else if (FPU_st0_tag == TW_Zero) ! 597: { ! 598: /* Number is zero */ ! 599: l[0] = l[1] = 0; ! 600: } ! 601: else if (FPU_st0_tag == TW_Infinity) ! 602: { ! 603: l[0] = 0; ! 604: l[1] = 0x7ff00000; ! 605: } ! 606: else if (FPU_st0_tag == TW_NaN) ! 607: { ! 608: /* See if we can get a valid NaN from the FPU_REG */ ! 609: l[0] = (FPU_st0_ptr->sigl >> 11) | (FPU_st0_ptr->sigh << 21); ! 610: l[1] = ((FPU_st0_ptr->sigh >> 11) & 0xfffff); ! 611: if ( !(l[0] | l[1]) ) ! 612: { ! 613: /* This case does not seem to be handled by the 80486 specs */ ! 614: EXCEPTION(EX_Invalid); ! 615: /* Make the quiet NaN "real indefinite" */ ! 616: goto put_indefinite; ! 617: } ! 618: l[1] |= 0x7ff00000; ! 619: } ! 620: else if ( FPU_st0_tag == TW_Empty ) ! 621: { ! 622: /* Empty register (stack underflow) */ ! 623: EXCEPTION(EX_StackUnder); ! 624: if ( control_word & EX_Invalid ) ! 625: { ! 626: /* The masked response */ ! 627: /* Put out the QNaN indefinite */ ! 628: put_indefinite: ! 629: RE_ENTRANT_CHECK_OFF ! 630: #ifdef COHERENT ! 631: if (verify_area((void *)dfloat,8)) { ! 632: put_fs_long(0, (unsigned long *) dfloat); ! 633: put_fs_long(0xfff80000, 1 + (unsigned long *) dfloat); ! 634: } ! 635: #else ! 636: verify_area((void *)dfloat,8); ! 637: put_fs_long(0, (unsigned long *) dfloat); ! 638: put_fs_long(0xfff80000, 1 + (unsigned long *) dfloat); ! 639: #endif ! 640: RE_ENTRANT_CHECK_ON ! 641: return 1; ! 642: } ! 643: else ! 644: return 0; ! 645: } ! 646: else if (FPU_st0_tag == TW_Denormal) ! 647: { ! 648: /* Extended real -> double real will always underflow */ ! 649: l[0] = l[1] = 0; ! 650: EXCEPTION(EX_Underflow); ! 651: } ! 652: if (FPU_st0_ptr->sign) ! 653: l[1] |= 0x80000000; ! 654: ! 655: RE_ENTRANT_CHECK_OFF ! 656: #ifdef COHERENT ! 657: if (verify_area((void *)dfloat,8)) { ! 658: put_fs_long(l[0], (unsigned long *)dfloat); ! 659: put_fs_long(l[1], 1 + (unsigned long *)dfloat); ! 660: } ! 661: #else ! 662: verify_area((void *)dfloat,8); ! 663: put_fs_long(l[0], (unsigned long *)dfloat); ! 664: put_fs_long(l[1], 1 + (unsigned long *)dfloat); ! 665: #endif ! 666: RE_ENTRANT_CHECK_ON ! 667: ! 668: return 1; ! 669: ! 670: } ! 671: ! 672: ! 673: /* Put a float into user memory */ ! 674: int reg_store_single(void) ! 675: { ! 676: float *single = (float *)FPU_data_address; ! 677: long templ; ! 678: int exp = FPU_st0_ptr->exp - EXP_BIAS; ! 679: unsigned long sigh = FPU_st0_ptr->sigh; ! 680: ! 681: ! 682: if (FPU_st0_tag == TW_Valid) ! 683: { ! 684: if ( ((sigh & 0xff) > 0x80) /* more than half */ ! 685: || ((sigh & 0x180) == 0x180) ) /* round to even */ ! 686: { ! 687: /* Round up */ ! 688: if ( sigh >= 0xffffff00 ) ! 689: { ! 690: /* sigh would overflow */ ! 691: exp++; ! 692: sigh = 0x80000000; ! 693: } ! 694: else ! 695: { ! 696: sigh += 0x100; ! 697: } ! 698: } ! 699: templ = (sigh >> 8) & 0x007fffff; ! 700: if ( exp > SINGLE_Emax ) ! 701: { ! 702: EXCEPTION(EX_Overflow); ! 703: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 704: if ( control_word & EX_Overflow ) ! 705: { ! 706: /* Overflow to infinity */ ! 707: templ = 0x7f800000; ! 708: } ! 709: else ! 710: return 0; ! 711: } ! 712: else if ( exp < SINGLE_Emin ) ! 713: { ! 714: if ( exp > SINGLE_Emin-24 ) ! 715: { ! 716: /* Make a de-normal */ ! 717: FPU_REG tmp; ! 718: EXCEPTION(EX_Denormal); ! 719: reg_move(FPU_st0_ptr, &tmp); ! 720: tmp.exp += -SINGLE_Emin + 23; /* largest exp to be 22 */ ! 721: round_to_int(&tmp); ! 722: templ = tmp.sigl; ! 723: } ! 724: else ! 725: { ! 726: EXCEPTION(EX_Underflow); ! 727: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 728: if ( control_word & EX_Underflow ) ! 729: { ! 730: /* Underflow to zero */ ! 731: templ = 0; ! 732: } ! 733: else ! 734: return 0; ! 735: } ! 736: } ! 737: else ! 738: templ |= ((exp+SINGLE_Ebias) & 0xff) << 23; ! 739: } ! 740: else if (FPU_st0_tag == TW_Zero) ! 741: { ! 742: templ = 0; ! 743: } ! 744: else if (FPU_st0_tag == TW_Infinity) ! 745: { ! 746: templ = 0x7f800000; ! 747: } ! 748: else if (FPU_st0_tag == TW_NaN) ! 749: { ! 750: /* See if we can get a valid NaN from the FPU_REG */ ! 751: templ = FPU_st0_ptr->sigh >> 8; ! 752: if ( !(templ & 0x3fffff) ) ! 753: { ! 754: /* This case does not seem to be handled by the 80486 specs */ ! 755: EXCEPTION(EX_Invalid); ! 756: /* Make the quiet NaN "real indefinite" */ ! 757: goto put_indefinite; ! 758: } ! 759: templ |= 0x7f800000; ! 760: } ! 761: else if ( FPU_st0_tag == TW_Empty ) ! 762: { ! 763: /* Empty register (stack underflow) */ ! 764: EXCEPTION(EX_StackUnder); ! 765: if ( control_word & EX_Invalid ) ! 766: { ! 767: /* The masked response */ ! 768: /* Put out the QNaN indefinite */ ! 769: put_indefinite: ! 770: RE_ENTRANT_CHECK_OFF ! 771: #ifdef COHERENT ! 772: if (verify_area((void *)single,4)) ! 773: put_fs_long(0xffc00000, (unsigned long *) single); ! 774: #else ! 775: verify_area((void *)single,4); ! 776: put_fs_long(0xffc00000, (unsigned long *) single); ! 777: #endif ! 778: RE_ENTRANT_CHECK_ON ! 779: return 1; ! 780: } ! 781: else ! 782: return 0; ! 783: } ! 784: else if (FPU_st0_tag == TW_Denormal) ! 785: { ! 786: /* Extended real -> real will always underflow */ ! 787: templ = 0; ! 788: EXCEPTION(EX_Underflow); ! 789: } ! 790: #ifdef PARANOID ! 791: else ! 792: { ! 793: EXCEPTION(EX_INTERNAL|0x106); ! 794: return 0; ! 795: } ! 796: #endif ! 797: if (FPU_st0_ptr->sign) ! 798: templ |= 0x80000000; ! 799: ! 800: RE_ENTRANT_CHECK_OFF ! 801: #ifdef COHERENT ! 802: if (verify_area((void *)single,4)) ! 803: put_fs_long(templ,(unsigned long *) single); ! 804: #else ! 805: verify_area((void *)single,4); ! 806: put_fs_long(templ,(unsigned long *) single); ! 807: #endif ! 808: RE_ENTRANT_CHECK_ON ! 809: ! 810: return 1; ! 811: } ! 812: ! 813: ! 814: /* Put a long long into user memory */ ! 815: int reg_store_int64(void) ! 816: { ! 817: long long *d = (long long *)FPU_data_address; ! 818: FPU_REG t; ! 819: long long tll; ! 820: ! 821: if ( FPU_st0_tag == TW_Empty ) ! 822: { ! 823: /* Empty register (stack underflow) */ ! 824: EXCEPTION(EX_StackUnder); ! 825: if ( control_word & EX_Invalid ) ! 826: { ! 827: /* The masked response */ ! 828: /* Put out the QNaN indefinite */ ! 829: goto put_indefinite; ! 830: } ! 831: else ! 832: return 0; ! 833: } ! 834: ! 835: reg_move(FPU_st0_ptr, &t); ! 836: round_to_int(&t); ! 837: ((long *)&tll)[0] = t.sigl; ! 838: ((long *)&tll)[1] = t.sigh; ! 839: if ( (t.sigh & 0x80000000) && ! 840: !((t.sigh == 0x80000000) && (t.sigl == 0) && (t.sign == SIGN_NEG)) ) ! 841: { ! 842: EXCEPTION(EX_Invalid); ! 843: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 844: if ( control_word & EX_Invalid ) ! 845: { ! 846: /* Produce "indefinite" */ ! 847: put_indefinite: ! 848: ((long *)&tll)[1] = 0x80000000; ! 849: ((long *)&tll)[0] = 0; ! 850: } ! 851: else ! 852: return 0; ! 853: } ! 854: else if ( t.sign ) ! 855: tll = - tll; ! 856: ! 857: RE_ENTRANT_CHECK_OFF ! 858: #ifdef COHERENT ! 859: if (verify_area((void *)d,8)) { ! 860: put_fs_long(((long *)&tll)[0],(unsigned long *) d); ! 861: put_fs_long(((long *)&tll)[1],1 + (unsigned long *) d); ! 862: } ! 863: #else ! 864: verify_area((void *)d,8); ! 865: put_fs_long(((long *)&tll)[0],(unsigned long *) d); ! 866: put_fs_long(((long *)&tll)[1],1 + (unsigned long *) d); ! 867: #endif ! 868: RE_ENTRANT_CHECK_ON ! 869: ! 870: return 1; ! 871: } ! 872: ! 873: ! 874: /* Put a long into user memory */ ! 875: int reg_store_int32(void) ! 876: { ! 877: long *d = (long *)FPU_data_address; ! 878: FPU_REG t; ! 879: ! 880: if ( FPU_st0_tag == TW_Empty ) ! 881: { ! 882: /* Empty register (stack underflow) */ ! 883: EXCEPTION(EX_StackUnder); ! 884: if ( control_word & EX_Invalid ) ! 885: { ! 886: /* The masked response */ ! 887: /* Put out the QNaN indefinite */ ! 888: RE_ENTRANT_CHECK_OFF ! 889: #ifdef COHERENT ! 890: if (verify_area(d,4)) ! 891: put_fs_long(0x80000000, (unsigned long *) d); ! 892: #else ! 893: verify_area(d,4); ! 894: put_fs_long(0x80000000, (unsigned long *) d); ! 895: #endif ! 896: RE_ENTRANT_CHECK_ON ! 897: return 1; ! 898: } ! 899: else ! 900: return 0; ! 901: } ! 902: ! 903: reg_move(FPU_st0_ptr, &t); ! 904: round_to_int(&t); ! 905: if (t.sigh || ! 906: ((t.sigl & 0x80000000) && ! 907: !((t.sigl == 0x80000000) && (t.sign == SIGN_NEG))) ) ! 908: { ! 909: EXCEPTION(EX_Invalid); ! 910: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 911: if ( control_word & EX_Invalid ) ! 912: { ! 913: /* Produce "indefinite" */ ! 914: t.sigl = 0x80000000; ! 915: } ! 916: else ! 917: return 0; ! 918: } ! 919: else if ( t.sign ) ! 920: t.sigl = -(long)t.sigl; ! 921: ! 922: RE_ENTRANT_CHECK_OFF ! 923: #ifdef COHERENT ! 924: if (verify_area(d,4)) ! 925: put_fs_long(t.sigl, (unsigned long *) d); ! 926: #else ! 927: verify_area(d,4); ! 928: put_fs_long(t.sigl, (unsigned long *) d); ! 929: #endif ! 930: RE_ENTRANT_CHECK_ON ! 931: ! 932: return 1; ! 933: } ! 934: ! 935: ! 936: /* Put a short into user memory */ ! 937: int reg_store_int16(void) ! 938: { ! 939: short *d = (short *)FPU_data_address; ! 940: FPU_REG t; ! 941: short ts; ! 942: ! 943: if ( FPU_st0_tag == TW_Empty ) ! 944: { ! 945: /* Empty register (stack underflow) */ ! 946: EXCEPTION(EX_StackUnder); ! 947: if ( control_word & EX_Invalid ) ! 948: { ! 949: /* The masked response */ ! 950: /* Put out the QNaN indefinite */ ! 951: RE_ENTRANT_CHECK_OFF ! 952: #ifdef COHERENT ! 953: if (verify_area(d,2)) ! 954: put_fs_word(0x8000, (unsigned short *) d); ! 955: #else ! 956: verify_area(d,2); ! 957: put_fs_word(0x8000, (unsigned short *) d); ! 958: #endif ! 959: RE_ENTRANT_CHECK_ON ! 960: return 1; ! 961: } ! 962: else ! 963: return 0; ! 964: } ! 965: ! 966: reg_move(FPU_st0_ptr, &t); ! 967: round_to_int(&t); ! 968: if (t.sigh || ! 969: ((t.sigl & 0xffff8000) && ! 970: !((t.sigl == 0x8000) && (t.sign == SIGN_NEG))) ) ! 971: { ! 972: EXCEPTION(EX_Invalid); ! 973: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 974: if ( control_word & EX_Invalid ) ! 975: { ! 976: /* Produce "indefinite" */ ! 977: ts = 0x8000; ! 978: } ! 979: else ! 980: return 0; ! 981: } ! 982: else if ( t.sign ) ! 983: t.sigl = -t.sigl; ! 984: ! 985: RE_ENTRANT_CHECK_OFF ! 986: #ifdef COHERENT ! 987: if (verify_area(d,2)) ! 988: put_fs_word((short)t.sigl,(short *) d); ! 989: #else ! 990: verify_area(d,2); ! 991: put_fs_word((short)t.sigl,(short *) d); ! 992: #endif ! 993: RE_ENTRANT_CHECK_ON ! 994: ! 995: return 1; ! 996: } ! 997: ! 998: ! 999: /* Put a packed bcd array into user memory */ ! 1000: int reg_store_bcd(void) ! 1001: { ! 1002: char *d = (char *)FPU_data_address; ! 1003: FPU_REG t; ! 1004: long long ll; ! 1005: unsigned char b; ! 1006: int i; ! 1007: unsigned char sign = (FPU_st0_ptr->sign == SIGN_NEG) ? 0x80 : 0; ! 1008: ! 1009: if ( FPU_st0_tag == TW_Empty ) ! 1010: { ! 1011: /* Empty register (stack underflow) */ ! 1012: EXCEPTION(EX_StackUnder); ! 1013: if ( control_word & EX_Invalid ) ! 1014: { ! 1015: /* The masked response */ ! 1016: /* Put out the QNaN indefinite */ ! 1017: goto put_indefinite; ! 1018: } ! 1019: else ! 1020: return 0; ! 1021: } ! 1022: ! 1023: reg_move(FPU_st0_ptr, &t); ! 1024: round_to_int(&t); ! 1025: ll = *(long long *)(&t.sigl); ! 1026: ! 1027: /* Check for overflow, by comparing with 999999999999999999 decimal. */ ! 1028: if ( (t.sigh > 0x0de0b6b3) || ! 1029: ((t.sigh == 0x0de0b6b3) && (t.sigl > 0xa763ffff)) ) ! 1030: { ! 1031: EXCEPTION(EX_Invalid); ! 1032: /* This is a special case: see sec 16.2.5.1 of the 80486 book */ ! 1033: if ( control_word & EX_Invalid ) ! 1034: { ! 1035: put_indefinite: ! 1036: /* Produce "indefinite" */ ! 1037: RE_ENTRANT_CHECK_OFF ! 1038: #ifdef COHERENT ! 1039: if (verify_area(d,10)) { ! 1040: put_fs_byte(0xff,(unsigned char *) d+7); ! 1041: put_fs_byte(0xff,(unsigned char *) d+8); ! 1042: put_fs_byte(0xff,(unsigned char *) d+9); ! 1043: } ! 1044: #else ! 1045: verify_area(d,10); ! 1046: put_fs_byte(0xff,(unsigned char *) d+7); ! 1047: put_fs_byte(0xff,(unsigned char *) d+8); ! 1048: put_fs_byte(0xff,(unsigned char *) d+9); ! 1049: #endif ! 1050: RE_ENTRANT_CHECK_ON ! 1051: return 1; ! 1052: } ! 1053: else ! 1054: return 0; ! 1055: } ! 1056: #ifdef COHERENT ! 1057: if (!verify_area(d,10)) ! 1058: return 1; ! 1059: #else ! 1060: verify_area(d,10); ! 1061: #endif ! 1062: for ( i = 0; i < 9; i++) ! 1063: { ! 1064: b = div_small(&ll, 10); ! 1065: b |= (div_small(&ll, 10)) << 4; ! 1066: RE_ENTRANT_CHECK_OFF ! 1067: put_fs_byte(b,(unsigned char *) d+i); ! 1068: RE_ENTRANT_CHECK_ON ! 1069: } ! 1070: RE_ENTRANT_CHECK_OFF ! 1071: put_fs_byte(sign,(unsigned char *) d+9); ! 1072: RE_ENTRANT_CHECK_ON ! 1073: ! 1074: return 1; ! 1075: } ! 1076: ! 1077: /*===========================================================================*/ ! 1078: ! 1079: /* r gets mangled such that sig is int, sign: ! 1080: it is NOT normalized*/ ! 1081: /* Overflow is signalled by a non-zero return value (in eax). ! 1082: In the case of overflow, the returned significand always has the ! 1083: the largest possible value */ ! 1084: /* The value returned in eax is never actually needed :-) */ ! 1085: int round_to_int(FPU_REG *r) ! 1086: { ! 1087: char very_big; ! 1088: unsigned eax; ! 1089: ! 1090: if (r->tag == TW_Zero) ! 1091: { ! 1092: /* Make sure that zero is returned */ ! 1093: *(long long *)&r->sigl = 0; ! 1094: return 0; /* o.k. */ ! 1095: } ! 1096: ! 1097: if (r->exp > EXP_BIAS + 63) ! 1098: { ! 1099: r->sigl = r->sigh = ~0; /* The largest representable number */ ! 1100: return 1; /* overflow */ ! 1101: } ! 1102: ! 1103: eax = shrxs(&r->sigl, EXP_BIAS + 63 - r->exp); ! 1104: very_big = !(~(r->sigh) | ~(r->sigl)); /* test for 0xfff...fff */ ! 1105: #define half_or_more (eax & 0x80000000) ! 1106: #define frac_part (eax) ! 1107: #define more_than_half ((eax & 0x80000001) == 0x80000001) ! 1108: switch (control_word & CW_RC) ! 1109: { ! 1110: case RC_RND: ! 1111: if ( more_than_half /* nearest */ ! 1112: || (half_or_more && (r->sigl & 1)) ) /* odd -> even */ ! 1113: { ! 1114: if ( very_big ) return 1; /* overflow */ ! 1115: (*(long long *)(&r->sigl)) ++; ! 1116: } ! 1117: break; ! 1118: case RC_DOWN: ! 1119: if (frac_part && r->sign) ! 1120: { ! 1121: if ( very_big ) return 1; /* overflow */ ! 1122: (*(long long *)(&r->sigl)) ++; ! 1123: } ! 1124: break; ! 1125: case RC_UP: ! 1126: if (frac_part && !r->sign) ! 1127: { ! 1128: if ( very_big ) return 1; /* overflow */ ! 1129: (*(long long *)(&r->sigl)) ++; ! 1130: } ! 1131: break; ! 1132: case RC_CHOP: ! 1133: break; ! 1134: } ! 1135: ! 1136: return 0; /* o.k. */ ! 1137: } ! 1138: ! 1139: /*===========================================================================*/ ! 1140: ! 1141: char *fldenv(void) ! 1142: { ! 1143: char *s = (char *)FPU_data_address; ! 1144: unsigned short tag_word = 0; ! 1145: unsigned char tag; ! 1146: int i; ! 1147: ! 1148: RE_ENTRANT_CHECK_OFF ! 1149: control_word = get_fs_word((unsigned short *) s); ! 1150: status_word = get_fs_word((unsigned short *) (s+4)); ! 1151: top = (status_word & SW_TOP) >> SW_TOPS; ! 1152: if (top) /* "top" is 0 or negative */ ! 1153: top |= ~7; ! 1154: tag_word = get_fs_word((unsigned short *) (s+8)); ! 1155: ip_offset = get_fs_long((unsigned long *) (s+0x0c)); ! 1156: cs_selector = get_fs_long((unsigned long *) (s+0x10)); ! 1157: data_operand_offset = get_fs_long((unsigned long *) (s+0x14)); ! 1158: operand_selector = get_fs_long((unsigned long *) (s+0x18)); ! 1159: RE_ENTRANT_CHECK_ON ! 1160: ! 1161: for ( i = 0; i < 8; i++ ) ! 1162: { ! 1163: tag = tag_word & 3; ! 1164: tag_word >>= 2; ! 1165: ! 1166: switch ( tag ) ! 1167: { ! 1168: case 0: ! 1169: fpregs[i].tag = TW_Valid; ! 1170: break; ! 1171: case 1: ! 1172: fpregs[i].tag = TW_Zero; ! 1173: break; ! 1174: case 2: ! 1175: fpregs[i].tag = TW_NaN; ! 1176: break; ! 1177: case 3: ! 1178: fpregs[i].tag = TW_Empty; ! 1179: break; ! 1180: } ! 1181: } ! 1182: ! 1183: FPU_data_address = (void *)data_operand_offset; /* We want no net effect */ ! 1184: FPU_entry_eip = ip_offset; /* We want no net effect */ ! 1185: ! 1186: return s + 0x1c; ! 1187: } ! 1188: ! 1189: ! 1190: void frstor(void) ! 1191: { ! 1192: int reg_index, stack_index; ! 1193: unsigned char tag; ! 1194: char *s = fldenv(); ! 1195: ! 1196: for ( stack_index = 0; stack_index < 8; stack_index++ ) ! 1197: { ! 1198: reg_index = (top + stack_index) & 7; ! 1199: ! 1200: /* load each register */ ! 1201: FPU_data_address = s + (stack_index * 10); ! 1202: reg_load_extended(); ! 1203: tag = fpregs[reg_index].tag; ! 1204: reg_move(&FPU_loaded_data, &fpregs[reg_index]); ! 1205: ! 1206: if ( tag == TW_NaN ) ! 1207: { ! 1208: unsigned char t = fpregs[reg_index].tag; ! 1209: if ( (t == TW_Valid) || (t == TW_Zero) ) ! 1210: fpregs[reg_index].tag = TW_NaN; ! 1211: } ! 1212: else ! 1213: fpregs[reg_index].tag = tag; ! 1214: } ! 1215: ! 1216: FPU_data_address = (void *)data_operand_offset; /* We want no net effect */ ! 1217: } ! 1218: ! 1219: ! 1220: char *fstenv(void) ! 1221: { ! 1222: char *d = (char *)FPU_data_address; ! 1223: unsigned short tag_word = 0; ! 1224: unsigned char tag; ! 1225: int i; ! 1226: ! 1227: #ifdef COHERENT ! 1228: if (!verify_area(d,28)) ! 1229: return d + 0x1c; ! 1230: #else ! 1231: verify_area(d,28); ! 1232: #endif ! 1233: for ( i = 7; i >= 0; i-- ) ! 1234: { ! 1235: switch ( tag = fpregs[i].tag ) ! 1236: { ! 1237: case TW_Denormal: ! 1238: case TW_Infinity: ! 1239: case TW_NaN: ! 1240: tag = 2; ! 1241: break; ! 1242: case TW_Empty: ! 1243: tag = 3; ! 1244: break; ! 1245: /* TW_Valid and TW_Zero already have the correct value */ ! 1246: } ! 1247: tag_word <<= 2; ! 1248: tag_word |= tag; ! 1249: } ! 1250: ! 1251: #ifndef COHERENT ! 1252: /* This is not what should be done ... but saves overheads. */ ! 1253: *(unsigned short *)&cs_selector = FPU_CS; ! 1254: *(unsigned short *)&operand_selector = FPU_DS; ! 1255: #endif ! 1256: ! 1257: RE_ENTRANT_CHECK_OFF ! 1258: put_fs_word(control_word, (unsigned short *) d); ! 1259: status_word &= ~SW_TOP; ! 1260: status_word |= (top & 7) << SW_TOPS; ! 1261: put_fs_word(status_word, (unsigned short *) (d+4)); ! 1262: put_fs_word(tag_word, (unsigned short *) (d+8)); ! 1263: put_fs_long(ip_offset, (unsigned long *) (d+0x0c)); ! 1264: put_fs_long(cs_selector, (unsigned long *) (d+0x10)); ! 1265: put_fs_long(data_operand_offset, (unsigned long *) (d+0x14)); ! 1266: put_fs_long(operand_selector, (unsigned long *) (d+0x18)); ! 1267: RE_ENTRANT_CHECK_ON ! 1268: ! 1269: return d + 0x1c; ! 1270: } ! 1271: ! 1272: /* Put a long double into user memory for fsave */ ! 1273: static void reg_store_ext(long double *d, FPU_REG *rg) ! 1274: { ! 1275: long e = rg->exp - EXP_BIAS + EXTENDED_Ebias; ! 1276: unsigned short sign = rg->sign*0x8000; ! 1277: unsigned long ls, ms; ! 1278: ! 1279: switch (rg->tag) { ! 1280: case TW_Valid: ! 1281: if ( e >= 0x7fff ) ! 1282: { ! 1283: /* Overflow to infinity */ ! 1284: e = 0x7fff; ! 1285: ls = 0; ! 1286: ms = 0x80000000; ! 1287: } ! 1288: else if ( e <= 0 ) ! 1289: { ! 1290: if ( e == 0 ) ! 1291: { ! 1292: ls = rg->sigl; ! 1293: ms = rg->sigh; ! 1294: } ! 1295: else if ( e > -64 ) ! 1296: { ! 1297: /* Make a de-normal */ ! 1298: FPU_REG tmp; ! 1299: ! 1300: reg_move(rg, &tmp); ! 1301: tmp.exp += -EXTENDED_Emin + 64; /* largest exp to be 63 */ ! 1302: round_to_int(&tmp); ! 1303: ! 1304: e = 0; ! 1305: ls = tmp.sigl; ! 1306: ms = tmp.sigh; ! 1307: } ! 1308: else ! 1309: { ! 1310: /* Underflow to zero */ ! 1311: e = 0; ! 1312: ls = 0; ! 1313: ms = 0; ! 1314: } ! 1315: } ! 1316: else ! 1317: { ! 1318: ls = rg->sigl; ! 1319: ms = rg->sigh; ! 1320: } ! 1321: break; ! 1322: case TW_Zero: ! 1323: e = 0; ! 1324: ls = ms = 0; ! 1325: break; ! 1326: case TW_Infinity: ! 1327: e = 0x7fff; ! 1328: ls = 0; ! 1329: ms = 0x80000000; ! 1330: break; ! 1331: case TW_NaN: ! 1332: e = 0x7fff; ! 1333: ls = rg->sigl; ! 1334: ms = rg->sigh; ! 1335: break; ! 1336: case TW_Empty: ! 1337: /* Empty register (stack underflow) */ ! 1338: /* Put out the QNaN indefinite */ ! 1339: e = 0xffff; ! 1340: ls = 0; ! 1341: ms = 0xc0000000; ! 1342: break; ! 1343: default: ! 1344: /* Store a NaN */ ! 1345: e = 0x7fff; ! 1346: ls = 1; ! 1347: ms = 0x80000000; ! 1348: } ! 1349: RE_ENTRANT_CHECK_OFF ! 1350: put_fs_long(ls, (unsigned long *) d); ! 1351: put_fs_long(ms, 1 + (unsigned long *) d); ! 1352: put_fs_word((unsigned short)e | sign, (short *)(2 + (unsigned long *)d)); ! 1353: RE_ENTRANT_CHECK_ON ! 1354: } ! 1355: ! 1356: void fsave(void) ! 1357: { ! 1358: char *d; ! 1359: int reg_index, stack_index; ! 1360: ! 1361: d = fstenv(); ! 1362: ! 1363: #ifdef COHERENT ! 1364: if (!verify_area(d,80)) ! 1365: return; ! 1366: #else ! 1367: verify_area(d,80); ! 1368: #endif ! 1369: for ( stack_index = 0; stack_index < 8; stack_index++ ) { ! 1370: reg_index = (top + stack_index) & 7; ! 1371: reg_store_ext((long double *)(d + (stack_index * 10)), ! 1372: fpregs + reg_index); ! 1373: } ! 1374: } ! 1375: ! 1376: /*===========================================================================*/
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.