1 /* 2 3 fp_arith.c: floating-point math routines for the Linux-m68k 4 floating point emulator. 5 6 Copyright (c) 1998-1999 David Huggins-Daines. 7 8 Somewhat based on the AlphaLinux floating point emulator, by David 9 Mosberger-Tang. 10 11 You may copy, modify, and redistribute this file under the terms of 12 the GNU General Public License, version 2, or any later version, at 13 your convenience. 14 */ 15 16 #include "fp_emu.h" 17 #include "multi_arith.h" 18 #include "fp_arith.h" 19 20 const struct fp_ext fp_QNaN = 21 { 22 .exp = 0x7fff, 23 .mant = { .m64 = ~0 } 24 }; 25 26 const struct fp_ext fp_Inf = 27 { 28 .exp = 0x7fff, 29 }; 30 31 /* let's start with the easy ones */ 32 33 struct fp_ext * 34 fp_fabs(struct fp_ext *dest, struct fp_ext *src) 35 { 36 dprint(PINSTR, "fabs\n"); 37 38 fp_monadic_check(dest, src); 39 40 dest->sign = 0; 41 42 return dest; 43 } 44 45 struct fp_ext * 46 fp_fneg(struct fp_ext *dest, struct fp_ext *src) 47 { 48 dprint(PINSTR, "fneg\n"); 49 50 fp_monadic_check(dest, src); 51 52 dest->sign = !dest->sign; 53 54 return dest; 55 } 56 57 /* Now, the slightly harder ones */ 58 59 /* fp_fadd: Implements the kernel of the FADD, FSADD, FDADD, FSUB, 60 FDSUB, and FCMP instructions. */ 61 62 struct fp_ext * 63 fp_fadd(struct fp_ext *dest, struct fp_ext *src) 64 { 65 int diff; 66 67 dprint(PINSTR, "fadd\n"); 68 69 fp_dyadic_check(dest, src); 70 71 if (IS_INF(dest)) { 72 /* infinity - infinity == NaN */ 73 if (IS_INF(src) && (src->sign != dest->sign)) 74 fp_set_nan(dest); 75 return dest; 76 } 77 if (IS_INF(src)) { 78 fp_copy_ext(dest, src); 79 return dest; 80 } 81 82 if (IS_ZERO(dest)) { 83 if (IS_ZERO(src)) { 84 if (src->sign != dest->sign) { 85 if (FPDATA->rnd == FPCR_ROUND_RM) 86 dest->sign = 1; 87 else 88 dest->sign = 0; 89 } 90 } else 91 fp_copy_ext(dest, src); 92 return dest; 93 } 94 95 dest->lowmant = src->lowmant = 0; 96 97 if ((diff = dest->exp - src->exp) > 0) 98 fp_denormalize(src, diff); 99 else if ((diff = -diff) > 0) 100 fp_denormalize(dest, diff); 101 102 if (dest->sign == src->sign) { 103 if (fp_addmant(dest, src)) 104 if (!fp_addcarry(dest)) 105 return dest; 106 } else { 107 if (dest->mant.m64 < src->mant.m64) { 108 fp_submant(dest, src, dest); 109 dest->sign = !dest->sign; 110 } else 111 fp_submant(dest, dest, src); 112 } 113 114 return dest; 115 } 116 117 /* fp_fsub: Implements the kernel of the FSUB, FSSUB, and FDSUB 118 instructions. 119 120 Remember that the arguments are in assembler-syntax order! */ 121 122 struct fp_ext * 123 fp_fsub(struct fp_ext *dest, struct fp_ext *src) 124 { 125 dprint(PINSTR, "fsub "); 126 127 src->sign = !src->sign; 128 return fp_fadd(dest, src); 129 } 130 131 132 struct fp_ext * 133 fp_fcmp(struct fp_ext *dest, struct fp_ext *src) 134 { 135 dprint(PINSTR, "fcmp "); 136 137 FPDATA->temp[1] = *dest; 138 src->sign = !src->sign; 139 return fp_fadd(&FPDATA->temp[1], src); 140 } 141 142 struct fp_ext * 143 fp_ftst(struct fp_ext *dest, struct fp_ext *src) 144 { 145 dprint(PINSTR, "ftst\n"); 146 147 (void)dest; 148 149 return src; 150 } 151 152 struct fp_ext * 153 fp_fmul(struct fp_ext *dest, struct fp_ext *src) 154 { 155 union fp_mant128 temp; 156 int exp; 157 158 dprint(PINSTR, "fmul\n"); 159 160 fp_dyadic_check(dest, src); 161 162 /* calculate the correct sign now, as it's necessary for infinities */ 163 dest->sign = src->sign ^ dest->sign; 164 165 /* Handle infinities */ 166 if (IS_INF(dest)) { 167 if (IS_ZERO(src)) 168 fp_set_nan(dest); 169 return dest; 170 } 171 if (IS_INF(src)) { 172 if (IS_ZERO(dest)) 173 fp_set_nan(dest); 174 else 175 fp_copy_ext(dest, src); 176 return dest; 177 } 178 179 /* Of course, as we all know, zero * anything = zero. You may 180 not have known that it might be a positive or negative 181 zero... */ 182 if (IS_ZERO(dest) || IS_ZERO(src)) { 183 dest->exp = 0; 184 dest->mant.m64 = 0; 185 dest->lowmant = 0; 186 187 return dest; 188 } 189 190 exp = dest->exp + src->exp - 0x3ffe; 191 192 /* shift up the mantissa for denormalized numbers, 193 so that the highest bit is set, this makes the 194 shift of the result below easier */ 195 if ((long)dest->mant.m32[0] >= 0) 196 exp -= fp_overnormalize(dest); 197 if ((long)src->mant.m32[0] >= 0) 198 exp -= fp_overnormalize(src); 199 200 /* now, do a 64-bit multiply with expansion */ 201 fp_multiplymant(&temp, dest, src); 202 203 /* normalize it back to 64 bits and stuff it back into the 204 destination struct */ 205 if ((long)temp.m32[0] > 0) { 206 exp--; 207 fp_putmant128(dest, &temp, 1); 208 } else 209 fp_putmant128(dest, &temp, 0); 210 211 if (exp >= 0x7fff) { 212 fp_set_ovrflw(dest); 213 return dest; 214 } 215 dest->exp = exp; 216 if (exp < 0) { 217 fp_set_sr(FPSR_EXC_UNFL); 218 fp_denormalize(dest, -exp); 219 } 220 221 return dest; 222 } 223 224 /* fp_fdiv: Implements the "kernel" of the FDIV, FSDIV, FDDIV and 225 FSGLDIV instructions. 226 227 Note that the order of the operands is counter-intuitive: instead 228 of src / dest, the result is actually dest / src. */ 229 230 struct fp_ext * 231 fp_fdiv(struct fp_ext *dest, struct fp_ext *src) 232 { 233 union fp_mant128 temp; 234 int exp; 235 236 dprint(PINSTR, "fdiv\n"); 237 238 fp_dyadic_check(dest, src); 239 240 /* calculate the correct sign now, as it's necessary for infinities */ 241 dest->sign = src->sign ^ dest->sign; 242 243 /* Handle infinities */ 244 if (IS_INF(dest)) { 245 /* infinity / infinity = NaN (quiet, as always) */ 246 if (IS_INF(src)) 247 fp_set_nan(dest); 248 /* infinity / anything else = infinity (with approprate sign) */ 249 return dest; 250 } 251 if (IS_INF(src)) { 252 /* anything / infinity = zero (with appropriate sign) */ 253 dest->exp = 0; 254 dest->mant.m64 = 0; 255 dest->lowmant = 0; 256 257 return dest; 258 } 259 260 /* zeroes */ 261 if (IS_ZERO(dest)) { 262 /* zero / zero = NaN */ 263 if (IS_ZERO(src)) 264 fp_set_nan(dest); 265 /* zero / anything else = zero */ 266 return dest; 267 } 268 if (IS_ZERO(src)) { 269 /* anything / zero = infinity (with appropriate sign) */ 270 fp_set_sr(FPSR_EXC_DZ); 271 dest->exp = 0x7fff; 272 dest->mant.m64 = 0; 273 274 return dest; 275 } 276 277 exp = dest->exp - src->exp + 0x3fff; 278 279 /* shift up the mantissa for denormalized numbers, 280 so that the highest bit is set, this makes lots 281 of things below easier */ 282 if ((long)dest->mant.m32[0] >= 0) 283 exp -= fp_overnormalize(dest); 284 if ((long)src->mant.m32[0] >= 0) 285 exp -= fp_overnormalize(src); 286 287 /* now, do the 64-bit divide */ 288 fp_dividemant(&temp, dest, src); 289 290 /* normalize it back to 64 bits and stuff it back into the 291 destination struct */ 292 if (!temp.m32[0]) { 293 exp--; 294 fp_putmant128(dest, &temp, 32); 295 } else 296 fp_putmant128(dest, &temp, 31); 297 298 if (exp >= 0x7fff) { 299 fp_set_ovrflw(dest); 300 return dest; 301 } 302 dest->exp = exp; 303 if (exp < 0) { 304 fp_set_sr(FPSR_EXC_UNFL); 305 fp_denormalize(dest, -exp); 306 } 307 308 return dest; 309 } 310 311 struct fp_ext * 312 fp_fsglmul(struct fp_ext *dest, struct fp_ext *src) 313 { 314 int exp; 315 316 dprint(PINSTR, "fsglmul\n"); 317 318 fp_dyadic_check(dest, src); 319 320 /* calculate the correct sign now, as it's necessary for infinities */ 321 dest->sign = src->sign ^ dest->sign; 322 323 /* Handle infinities */ 324 if (IS_INF(dest)) { 325 if (IS_ZERO(src)) 326 fp_set_nan(dest); 327 return dest; 328 } 329 if (IS_INF(src)) { 330 if (IS_ZERO(dest)) 331 fp_set_nan(dest); 332 else 333 fp_copy_ext(dest, src); 334 return dest; 335 } 336 337 /* Of course, as we all know, zero * anything = zero. You may 338 not have known that it might be a positive or negative 339 zero... */ 340 if (IS_ZERO(dest) || IS_ZERO(src)) { 341 dest->exp = 0; 342 dest->mant.m64 = 0; 343 dest->lowmant = 0; 344 345 return dest; 346 } 347 348 exp = dest->exp + src->exp - 0x3ffe; 349 350 /* do a 32-bit multiply */ 351 fp_mul64(dest->mant.m32[0], dest->mant.m32[1], 352 dest->mant.m32[0] & 0xffffff00, 353 src->mant.m32[0] & 0xffffff00); 354 355 if (exp >= 0x7fff) { 356 fp_set_ovrflw(dest); 357 return dest; 358 } 359 dest->exp = exp; 360 if (exp < 0) { 361 fp_set_sr(FPSR_EXC_UNFL); 362 fp_denormalize(dest, -exp); 363 } 364 365 return dest; 366 } 367 368 struct fp_ext * 369 fp_fsgldiv(struct fp_ext *dest, struct fp_ext *src) 370 { 371 int exp; 372 unsigned long quot, rem; 373 374 dprint(PINSTR, "fsgldiv\n"); 375 376 fp_dyadic_check(dest, src); 377 378 /* calculate the correct sign now, as it's necessary for infinities */ 379 dest->sign = src->sign ^ dest->sign; 380 381 /* Handle infinities */ 382 if (IS_INF(dest)) { 383 /* infinity / infinity = NaN (quiet, as always) */ 384 if (IS_INF(src)) 385 fp_set_nan(dest); 386 /* infinity / anything else = infinity (with approprate sign) */ 387 return dest; 388 } 389 if (IS_INF(src)) { 390 /* anything / infinity = zero (with appropriate sign) */ 391 dest->exp = 0; 392 dest->mant.m64 = 0; 393 dest->lowmant = 0; 394 395 return dest; 396 } 397 398 /* zeroes */ 399 if (IS_ZERO(dest)) { 400 /* zero / zero = NaN */ 401 if (IS_ZERO(src)) 402 fp_set_nan(dest); 403 /* zero / anything else = zero */ 404 return dest; 405 } 406 if (IS_ZERO(src)) { 407 /* anything / zero = infinity (with appropriate sign) */ 408 fp_set_sr(FPSR_EXC_DZ); 409 dest->exp = 0x7fff; 410 dest->mant.m64 = 0; 411 412 return dest; 413 } 414 415 exp = dest->exp - src->exp + 0x3fff; 416 417 dest->mant.m32[0] &= 0xffffff00; 418 src->mant.m32[0] &= 0xffffff00; 419 420 /* do the 32-bit divide */ 421 if (dest->mant.m32[0] >= src->mant.m32[0]) { 422 fp_sub64(dest->mant, src->mant); 423 fp_div64(quot, rem, dest->mant.m32[0], 0, src->mant.m32[0]); 424 dest->mant.m32[0] = 0x80000000 | (quot >> 1); 425 dest->mant.m32[1] = (quot & 1) | rem; /* only for rounding */ 426 } else { 427 fp_div64(quot, rem, dest->mant.m32[0], 0, src->mant.m32[0]); 428 dest->mant.m32[0] = quot; 429 dest->mant.m32[1] = rem; /* only for rounding */ 430 exp--; 431 } 432 433 if (exp >= 0x7fff) { 434 fp_set_ovrflw(dest); 435 return dest; 436 } 437 dest->exp = exp; 438 if (exp < 0) { 439 fp_set_sr(FPSR_EXC_UNFL); 440 fp_denormalize(dest, -exp); 441 } 442 443 return dest; 444 } 445 446 /* fp_roundint: Internal rounding function for use by several of these 447 emulated instructions. 448 449 This one rounds off the fractional part using the rounding mode 450 specified. */ 451 452 static void fp_roundint(struct fp_ext *dest, int mode) 453 { 454 union fp_mant64 oldmant; 455 unsigned long mask; 456 457 if (!fp_normalize_ext(dest)) 458 return; 459 460 /* infinities and zeroes */ 461 if (IS_INF(dest) || IS_ZERO(dest)) 462 return; 463 464 /* first truncate the lower bits */ 465 oldmant = dest->mant; 466 switch (dest->exp) { 467 case 0 ... 0x3ffe: 468 dest->mant.m64 = 0; 469 break; 470 case 0x3fff ... 0x401e: 471 dest->mant.m32[0] &= 0xffffffffU << (0x401e - dest->exp); 472 dest->mant.m32[1] = 0; 473 if (oldmant.m64 == dest->mant.m64) 474 return; 475 break; 476 case 0x401f ... 0x403e: 477 dest->mant.m32[1] &= 0xffffffffU << (0x403e - dest->exp); 478 if (oldmant.m32[1] == dest->mant.m32[1]) 479 return; 480 break; 481 default: 482 return; 483 } 484 fp_set_sr(FPSR_EXC_INEX2); 485 486 /* We might want to normalize upwards here... however, since 487 we know that this is only called on the output of fp_fdiv, 488 or with the input to fp_fint or fp_fintrz, and the inputs 489 to all these functions are either normal or denormalized 490 (no subnormals allowed!), there's really no need. 491 492 In the case of fp_fdiv, observe that 0x80000000 / 0xffff = 493 0xffff8000, and the same holds for 128-bit / 64-bit. (i.e. the 494 smallest possible normal dividend and the largest possible normal 495 divisor will still produce a normal quotient, therefore, (normal 496 << 64) / normal is normal in all cases) */ 497 498 switch (mode) { 499 case FPCR_ROUND_RN: 500 switch (dest->exp) { 501 case 0 ... 0x3ffd: 502 return; 503 case 0x3ffe: 504 /* As noted above, the input is always normal, so the 505 guard bit (bit 63) is always set. therefore, the 506 only case in which we will NOT round to 1.0 is when 507 the input is exactly 0.5. */ 508 if (oldmant.m64 == (1ULL << 63)) 509 return; 510 break; 511 case 0x3fff ... 0x401d: 512 mask = 1 << (0x401d - dest->exp); 513 if (!(oldmant.m32[0] & mask)) 514 return; 515 if (oldmant.m32[0] & (mask << 1)) 516 break; 517 if (!(oldmant.m32[0] << (dest->exp - 0x3ffd)) && 518 !oldmant.m32[1]) 519 return; 520 break; 521 case 0x401e: 522 if (!(oldmant.m32[1] >= 0)) 523 return; 524 if (oldmant.m32[0] & 1) 525 break; 526 if (!(oldmant.m32[1] << 1)) 527 return; 528 break; 529 case 0x401f ... 0x403d: 530 mask = 1 << (0x403d - dest->exp); 531 if (!(oldmant.m32[1] & mask)) 532 return; 533 if (oldmant.m32[1] & (mask << 1)) 534 break; 535 if (!(oldmant.m32[1] << (dest->exp - 0x401d))) 536 return; 537 break; 538 default: 539 return; 540 } 541 break; 542 case FPCR_ROUND_RZ: 543 return; 544 default: 545 if (dest->sign ^ (mode - FPCR_ROUND_RM)) 546 break; 547 return; 548 } 549 550 switch (dest->exp) { 551 case 0 ... 0x3ffe: 552 dest->exp = 0x3fff; 553 dest->mant.m64 = 1ULL << 63; 554 break; 555 case 0x3fff ... 0x401e: 556 mask = 1 << (0x401e - dest->exp); 557 if (dest->mant.m32[0] += mask) 558 break; 559 dest->mant.m32[0] = 0x80000000; 560 dest->exp++; 561 break; 562 case 0x401f ... 0x403e: 563 mask = 1 << (0x403e - dest->exp); 564 if (dest->mant.m32[1] += mask) 565 break; 566 if (dest->mant.m32[0] += 1) 567 break; 568 dest->mant.m32[0] = 0x80000000; 569 dest->exp++; 570 break; 571 } 572 } 573 574 /* modrem_kernel: Implementation of the FREM and FMOD instructions 575 (which are exactly the same, except for the rounding used on the 576 intermediate value) */ 577 578 static struct fp_ext * 579 modrem_kernel(struct fp_ext *dest, struct fp_ext *src, int mode) 580 { 581 struct fp_ext tmp; 582 583 fp_dyadic_check(dest, src); 584 585 /* Infinities and zeros */ 586 if (IS_INF(dest) || IS_ZERO(src)) { 587 fp_set_nan(dest); 588 return dest; 589 } 590 if (IS_ZERO(dest) || IS_INF(src)) 591 return dest; 592 593 /* FIXME: there is almost certainly a smarter way to do this */ 594 fp_copy_ext(&tmp, dest); 595 fp_fdiv(&tmp, src); /* NOTE: src might be modified */ 596 fp_roundint(&tmp, mode); 597 fp_fmul(&tmp, src); 598 fp_fsub(dest, &tmp); 599 600 /* set the quotient byte */ 601 fp_set_quotient((dest->mant.m64 & 0x7f) | (dest->sign << 7)); 602 return dest; 603 } 604 605 /* fp_fmod: Implements the kernel of the FMOD instruction. 606 607 Again, the argument order is backwards. The result, as defined in 608 the Motorola manuals, is: 609 610 fmod(src,dest) = (dest - (src * floor(dest / src))) */ 611 612 struct fp_ext * 613 fp_fmod(struct fp_ext *dest, struct fp_ext *src) 614 { 615 dprint(PINSTR, "fmod\n"); 616 return modrem_kernel(dest, src, FPCR_ROUND_RZ); 617 } 618 619 /* fp_frem: Implements the kernel of the FREM instruction. 620 621 frem(src,dest) = (dest - (src * round(dest / src))) 622 */ 623 624 struct fp_ext * 625 fp_frem(struct fp_ext *dest, struct fp_ext *src) 626 { 627 dprint(PINSTR, "frem\n"); 628 return modrem_kernel(dest, src, FPCR_ROUND_RN); 629 } 630 631 struct fp_ext * 632 fp_fint(struct fp_ext *dest, struct fp_ext *src) 633 { 634 dprint(PINSTR, "fint\n"); 635 636 fp_copy_ext(dest, src); 637 638 fp_roundint(dest, FPDATA->rnd); 639 640 return dest; 641 } 642 643 struct fp_ext * 644 fp_fintrz(struct fp_ext *dest, struct fp_ext *src) 645 { 646 dprint(PINSTR, "fintrz\n"); 647 648 fp_copy_ext(dest, src); 649 650 fp_roundint(dest, FPCR_ROUND_RZ); 651 652 return dest; 653 } 654 655 struct fp_ext * 656 fp_fscale(struct fp_ext *dest, struct fp_ext *src) 657 { 658 int scale, oldround; 659 660 dprint(PINSTR, "fscale\n"); 661 662 fp_dyadic_check(dest, src); 663 664 /* Infinities */ 665 if (IS_INF(src)) { 666 fp_set_nan(dest); 667 return dest; 668 } 669 if (IS_INF(dest)) 670 return dest; 671 672 /* zeroes */ 673 if (IS_ZERO(src) || IS_ZERO(dest)) 674 return dest; 675 676 /* Source exponent out of range */ 677 if (src->exp >= 0x400c) { 678 fp_set_ovrflw(dest); 679 return dest; 680 } 681 682 /* src must be rounded with round to zero. */ 683 oldround = FPDATA->rnd; 684 FPDATA->rnd = FPCR_ROUND_RZ; 685 scale = fp_conv_ext2long(src); 686 FPDATA->rnd = oldround; 687 688 /* new exponent */ 689 scale += dest->exp; 690 691 if (scale >= 0x7fff) { 692 fp_set_ovrflw(dest); 693 } else if (scale <= 0) { 694 fp_set_sr(FPSR_EXC_UNFL); 695 fp_denormalize(dest, -scale); 696 } else 697 dest->exp = scale; 698 699 return dest; 700 } 701 702