Changeset a35b458 in mainline for uspace/lib/softfloat
- Timestamp:
- 2018-03-02T20:10:49Z (7 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- f1380b7
- Parents:
- 3061bc1
- git-author:
- Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
- git-committer:
- Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
- Location:
- uspace/lib/softfloat
- Files:
-
- 8 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/softfloat/add.c
r3061bc1 ra35b458 49 49 int expdiff; 50 50 uint32_t exp1, exp2, frac1, frac2; 51 51 52 52 expdiff = a.parts.exp - b.parts.exp; 53 53 if (expdiff < 0) { … … 59 59 return b; 60 60 } 61 61 62 62 if (b.parts.exp == FLOAT32_MAX_EXPONENT) { 63 63 return b; 64 64 } 65 65 66 66 frac1 = b.parts.fraction; 67 67 exp1 = b.parts.exp; … … 76 76 return (is_float32_nan(a) ? a : b); 77 77 } 78 78 79 79 if (a.parts.exp == FLOAT32_MAX_EXPONENT) { 80 80 return a; 81 81 } 82 82 83 83 frac1 = a.parts.fraction; 84 84 exp1 = a.parts.exp; … … 86 86 exp2 = b.parts.exp; 87 87 } 88 88 89 89 if (exp1 == 0) { 90 90 /* both are denormalized */ … … 97 97 return a; 98 98 } 99 99 100 100 frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */ 101 101 … … 107 107 frac2 |= FLOAT32_HIDDEN_BIT_MASK; 108 108 } 109 109 110 110 /* create some space for rounding */ 111 111 frac1 <<= 6; 112 112 frac2 <<= 6; 113 113 114 114 if (expdiff < (FLOAT32_FRACTION_SIZE + 2)) { 115 115 frac2 >>= expdiff; … … 120 120 return a; 121 121 } 122 122 123 123 if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { 124 124 ++exp1; 125 125 frac1 >>= 1; 126 126 } 127 127 128 128 /* rounding - if first bit after fraction is set then round up */ 129 129 frac1 += (0x1 << 5); 130 130 131 131 if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { 132 132 /* rounding overflow */ … … 134 134 frac1 >>= 1; 135 135 } 136 136 137 137 if ((exp1 == FLOAT32_MAX_EXPONENT) || (exp2 > exp1)) { 138 138 /* overflow - set infinity as result */ … … 141 141 return a; 142 142 } 143 143 144 144 a.parts.exp = exp1; 145 145 146 146 /* Clear hidden bit and shift */ 147 147 a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); … … 160 160 uint32_t exp1, exp2; 161 161 uint64_t frac1, frac2; 162 162 163 163 expdiff = ((int) a.parts.exp) - b.parts.exp; 164 164 if (expdiff < 0) { … … 170 170 return b; 171 171 } 172 172 173 173 /* b is infinity and a not */ 174 174 if (b.parts.exp == FLOAT64_MAX_EXPONENT) { 175 175 return b; 176 176 } 177 177 178 178 frac1 = b.parts.fraction; 179 179 exp1 = b.parts.exp; … … 188 188 return a; 189 189 } 190 190 191 191 /* a is infinity and b not */ 192 192 if (a.parts.exp == FLOAT64_MAX_EXPONENT) { 193 193 return a; 194 194 } 195 195 196 196 frac1 = a.parts.fraction; 197 197 exp1 = a.parts.exp; … … 199 199 exp2 = b.parts.exp; 200 200 } 201 201 202 202 if (exp1 == 0) { 203 203 /* both are denormalized */ … … 210 210 return a; 211 211 } 212 212 213 213 /* add hidden bit - frac1 is sure not denormalized */ 214 214 frac1 |= FLOAT64_HIDDEN_BIT_MASK; … … 222 222 frac2 |= FLOAT64_HIDDEN_BIT_MASK; 223 223 } 224 224 225 225 /* create some space for rounding */ 226 226 frac1 <<= 6; 227 227 frac2 <<= 6; 228 228 229 229 if (expdiff < (FLOAT64_FRACTION_SIZE + 2)) { 230 230 frac2 >>= expdiff; … … 235 235 return a; 236 236 } 237 237 238 238 if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { 239 239 ++exp1; 240 240 frac1 >>= 1; 241 241 } 242 242 243 243 /* rounding - if first bit after fraction is set then round up */ 244 244 frac1 += (0x1 << 5); 245 245 246 246 if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { 247 247 /* rounding overflow */ … … 249 249 frac1 >>= 1; 250 250 } 251 251 252 252 if ((exp1 == FLOAT64_MAX_EXPONENT) || (exp2 > exp1)) { 253 253 /* overflow - set infinity as result */ … … 256 256 return a; 257 257 } 258 258 259 259 a.parts.exp = exp1; 260 260 /* Clear hidden bit and shift */ … … 400 400 401 401 a.parts.exp = exp1; 402 402 403 403 /* Clear hidden bit and shift */ 404 404 rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); … … 419 419 float32_u ua; 420 420 ua.val = a; 421 421 422 422 float32_u ub; 423 423 ub.val = b; 424 424 425 425 float32_u res; 426 426 427 427 if (ua.data.parts.sign != ub.data.parts.sign) { 428 428 if (ua.data.parts.sign) { … … 435 435 } else 436 436 res.data = add_float32(ua.data, ub.data); 437 437 438 438 return res.val; 439 439 } … … 443 443 float32_u ua; 444 444 ua.val = a; 445 445 446 446 float32_u ub; 447 447 ub.val = b; 448 448 449 449 float32_u res; 450 450 451 451 if (ua.data.parts.sign != ub.data.parts.sign) { 452 452 if (ua.data.parts.sign) { … … 459 459 } else 460 460 res.data = add_float32(ua.data, ub.data); 461 461 462 462 return res.val; 463 463 } … … 471 471 float64_u ua; 472 472 ua.val = a; 473 473 474 474 float64_u ub; 475 475 ub.val = b; 476 476 477 477 float64_u res; 478 478 479 479 if (ua.data.parts.sign != ub.data.parts.sign) { 480 480 if (ua.data.parts.sign) { … … 487 487 } else 488 488 res.data = add_float64(ua.data, ub.data); 489 489 490 490 return res.val; 491 491 } … … 495 495 float64_u ua; 496 496 ua.val = a; 497 497 498 498 float64_u ub; 499 499 ub.val = b; 500 500 501 501 float64_u res; 502 502 503 503 if (ua.data.parts.sign != ub.data.parts.sign) { 504 504 if (ua.data.parts.sign) { … … 511 511 } else 512 512 res.data = add_float64(ua.data, ub.data); 513 513 514 514 return res.val; 515 515 } … … 523 523 float128_u ua; 524 524 ua.val = a; 525 525 526 526 float128_u ub; 527 527 ub.val = b; 528 528 529 529 float128_u res; 530 530 531 531 if (ua.data.parts.sign != ub.data.parts.sign) { 532 532 if (ua.data.parts.sign) { … … 539 539 } else 540 540 res.data = add_float128(ua.data, ub.data); 541 541 542 542 return res.val; 543 543 } -
uspace/lib/softfloat/common.c
r3061bc1 ra35b458 78 78 /* TODO: fix underflow */ 79 79 } 80 80 81 81 if ((cexp < 0) || (cexp == 0 && 82 82 (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) { … … 87 87 return result; 88 88 } 89 89 90 90 while (cexp < 0) { 91 91 cexp++; 92 92 cfrac >>= 1; 93 93 } 94 94 95 95 cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); 96 96 97 97 if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) { 98 98 result.parts.fraction = … … 103 103 cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); 104 104 } 105 105 106 106 ++cexp; 107 107 … … 120 120 121 121 result.parts.exp = (uint32_t) cexp; 122 122 123 123 result.parts.fraction = 124 124 ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK)); 125 125 126 126 return result; 127 127 } … … 289 289 /* rounding - if first bit after fraction is set then round up */ 290 290 (*fraction) += (0x1 << (32 - FLOAT32_FRACTION_SIZE - 3)); 291 291 292 292 if ((*fraction) & 293 293 (FLOAT32_HIDDEN_BIT_MASK << (32 - FLOAT32_FRACTION_SIZE - 1))) { … … 296 296 (*fraction) >>= 1; 297 297 } 298 298 299 299 if (((*exp) >= FLOAT32_MAX_EXPONENT) || ((*exp) < 0)) { 300 300 /* overflow - set infinity as result */ … … 322 322 */ 323 323 (*fraction) += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); 324 324 325 325 /* See if there was a carry to bit 63. */ 326 326 if ((*fraction) & … … 330 330 (*fraction) >>= 1; 331 331 } 332 332 333 333 if (((*exp) >= FLOAT64_MAX_EXPONENT) || ((*exp) < 0)) { 334 334 /* overflow - set infinity as result */ … … 677 677 mul64(b, result, &tmp_hi, &tmp_lo); 678 678 sub128(a_hi, a_lo, tmp_hi, tmp_lo, &rem_hi, &rem_lo); 679 679 680 680 while ((int64_t) rem_hi < 0) { 681 681 result -= 0x1ll << 32; -
uspace/lib/softfloat/comparison.c
r3061bc1 ra35b458 190 190 uint64_t tmp_hi; 191 191 uint64_t tmp_lo; 192 192 193 193 and128(ld.bin.hi, ld.bin.lo, 194 194 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); 195 195 196 196 return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll); 197 197 } … … 236 236 uint64_t tmp_hi; 237 237 uint64_t tmp_lo; 238 238 239 239 /* both are zeros (with any sign) */ 240 240 or128(a.bin.hi, a.bin.lo, … … 243 243 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); 244 244 int both_zero = eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll); 245 245 246 246 /* a equals to b */ 247 247 int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); 248 248 249 249 return are_equal || both_zero; 250 250 } … … 263 263 return 0; 264 264 } 265 265 266 266 if ((a.parts.sign) && (b.parts.sign)) { 267 267 /* if both are negative, smaller is that with greater binary value */ 268 268 return (a.bin > b.bin); 269 269 } 270 270 271 271 /* 272 272 * lets negate signs - now will be positive numbers always … … 292 292 return 0; 293 293 } 294 294 295 295 if ((a.parts.sign) && (b.parts.sign)) { 296 296 /* if both are negative, smaller is that with greater binary value */ 297 297 return (a.bin > b.bin); 298 298 } 299 299 300 300 /* 301 301 * lets negate signs - now will be positive numbers always … … 319 319 uint64_t tmp_hi; 320 320 uint64_t tmp_lo; 321 321 322 322 or128(a.bin.hi, a.bin.lo, 323 323 b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); … … 328 328 return 0; 329 329 } 330 330 331 331 if ((a.parts.sign) && (b.parts.sign)) { 332 332 /* if both are negative, smaller is that with greater binary value */ 333 333 return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo); 334 334 } 335 335 336 336 /* 337 337 * lets negate signs - now will be positive numbers always … … 357 357 return 0; 358 358 } 359 359 360 360 if ((a.parts.sign) && (b.parts.sign)) { 361 361 /* if both are negative, greater is that with smaller binary value */ 362 362 return (a.bin < b.bin); 363 363 } 364 364 365 365 /* 366 366 * lets negate signs - now will be positive numbers always … … 386 386 return 0; 387 387 } 388 388 389 389 if ((a.parts.sign) && (b.parts.sign)) { 390 390 /* if both are negative, greater is that with smaller binary value */ 391 391 return (a.bin < b.bin); 392 392 } 393 393 394 394 /* 395 395 * lets negate signs - now will be positive numbers always … … 413 413 uint64_t tmp_hi; 414 414 uint64_t tmp_lo; 415 415 416 416 or128(a.bin.hi, a.bin.lo, 417 417 b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); … … 422 422 return 0; 423 423 } 424 424 425 425 if ((a.parts.sign) && (b.parts.sign)) { 426 426 /* if both are negative, greater is that with smaller binary value */ 427 427 return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); 428 428 } 429 429 430 430 /* 431 431 * lets negate signs - now will be positive numbers always … … 444 444 float32_u ua; 445 445 ua.val = a; 446 446 447 447 float32_u ub; 448 448 ub.val = b; 449 449 450 450 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 451 451 // TODO: sigNaNs 452 452 return -1; 453 453 } 454 454 455 455 if (is_float32_gt(ua.data, ub.data)) 456 456 return 1; 457 457 458 458 return 0; 459 459 } … … 463 463 float32_u ua; 464 464 ua.val = a; 465 465 466 466 float32_u ub; 467 467 ub.val = b; 468 468 469 469 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 470 470 // TODO: sigNaNs 471 471 return -1; 472 472 } 473 473 474 474 if (is_float32_eq(ua.data, ub.data)) 475 475 return 0; 476 476 477 477 if (is_float32_gt(ua.data, ub.data)) 478 478 return 1; 479 479 480 480 return -1; 481 481 } … … 485 485 float32_u ua; 486 486 ua.val = a; 487 487 488 488 float32_u ub; 489 489 ub.val = b; 490 490 491 491 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 492 492 // TODO: sigNaNs 493 493 return 1; 494 494 } 495 495 496 496 if (is_float32_lt(ua.data, ub.data)) 497 497 return -1; 498 498 499 499 return 0; 500 500 } … … 504 504 float32_u ua; 505 505 ua.val = a; 506 506 507 507 float32_u ub; 508 508 ub.val = b; 509 509 510 510 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 511 511 // TODO: sigNaNs 512 512 return 1; 513 513 } 514 514 515 515 if (is_float32_eq(ua.data, ub.data)) 516 516 return 0; 517 517 518 518 if (is_float32_lt(ua.data, ub.data)) 519 519 return -1; 520 520 521 521 return 1; 522 522 } … … 526 526 float32_u ua; 527 527 ua.val = a; 528 528 529 529 float32_u ub; 530 530 ub.val = b; 531 531 532 532 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 533 533 // TODO: sigNaNs 534 534 return 1; 535 535 } 536 536 537 537 return is_float32_eq(ua.data, ub.data) - 1; 538 538 } … … 548 548 float32_u ua; 549 549 ua.val = a; 550 550 551 551 float32_u ub; 552 552 ub.val = b; 553 553 554 554 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 555 555 /* No special constant for unordered - maybe signaled? */ 556 556 return 1; 557 557 } 558 558 559 559 if (is_float32_eq(ua.data, ub.data)) 560 560 return 0; 561 561 562 562 if (is_float32_lt(ua.data, ub.data)) 563 563 return -1; 564 564 565 565 return 1; 566 566 } … … 570 570 float32_u ua; 571 571 ua.val = a; 572 572 573 573 float32_u ub; 574 574 ub.val = b; 575 575 576 576 return ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))); 577 577 } … … 581 581 float32_u ua; 582 582 ua.val = a; 583 583 584 584 float32_u ub; 585 585 ub.val = b; 586 586 587 587 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 588 588 // TODO: sigNaNs 589 589 return -1; 590 590 } 591 591 592 592 if (is_float32_gt(ua.data, ub.data)) 593 593 return 1; 594 594 595 595 return 0; 596 596 } … … 600 600 float32_u ua; 601 601 ua.val = a; 602 602 603 603 float32_u ub; 604 604 ub.val = b; 605 605 606 606 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 607 607 // TODO: sigNaNs 608 608 return 1; 609 609 } 610 610 611 611 if (is_float32_lt(ua.data, ub.data)) 612 612 return -1; 613 613 614 614 return 0; 615 615 } … … 619 619 float32_u ua; 620 620 ua.val = a; 621 621 622 622 float32_u ub; 623 623 ub.val = b; 624 624 625 625 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 626 626 // TODO: sigNaNs 627 627 return -1; 628 628 } 629 629 630 630 if (is_float32_eq(ua.data, ub.data)) 631 631 return 0; 632 632 633 633 if (is_float32_gt(ua.data, ub.data)) 634 634 return 1; 635 635 636 636 return -1; 637 637 } … … 641 641 float32_u ua; 642 642 ua.val = a; 643 643 644 644 float32_u ub; 645 645 ub.val = b; 646 646 647 647 if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { 648 648 // TODO: sigNaNs 649 649 return 1; 650 650 } 651 651 652 652 return is_float32_eq(ua.data, ub.data) - 1; 653 653 } … … 661 661 float64_u ua; 662 662 ua.val = a; 663 663 664 664 float64_u ub; 665 665 ub.val = b; 666 666 667 667 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 668 668 // TODO: sigNaNs 669 669 return -1; 670 670 } 671 671 672 672 if (is_float64_gt(ua.data, ub.data)) 673 673 return 1; 674 674 675 675 return 0; 676 676 } … … 680 680 float64_u ua; 681 681 ua.val = a; 682 682 683 683 float64_u ub; 684 684 ub.val = b; 685 685 686 686 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 687 687 // TODO: sigNaNs 688 688 return -1; 689 689 } 690 690 691 691 if (is_float64_eq(ua.data, ub.data)) 692 692 return 0; 693 693 694 694 if (is_float64_gt(ua.data, ub.data)) 695 695 return 1; 696 696 697 697 return -1; 698 698 } … … 702 702 float64_u ua; 703 703 ua.val = a; 704 704 705 705 float64_u ub; 706 706 ub.val = b; 707 707 708 708 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 709 709 // TODO: sigNaNs 710 710 return 1; 711 711 } 712 712 713 713 if (is_float64_lt(ua.data, ub.data)) 714 714 return -1; 715 715 716 716 return 0; 717 717 } … … 721 721 float64_u ua; 722 722 ua.val = a; 723 723 724 724 float64_u ub; 725 725 ub.val = b; 726 726 727 727 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 728 728 // TODO: sigNaNs 729 729 return 1; 730 730 } 731 731 732 732 if (is_float64_eq(ua.data, ub.data)) 733 733 return 0; 734 734 735 735 if (is_float64_lt(ua.data, ub.data)) 736 736 return -1; 737 737 738 738 return 1; 739 739 } … … 743 743 float64_u ua; 744 744 ua.val = a; 745 745 746 746 float64_u ub; 747 747 ub.val = b; 748 748 749 749 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 750 750 // TODO: sigNaNs 751 751 return 1; 752 752 } 753 753 754 754 return is_float64_eq(ua.data, ub.data) - 1; 755 755 } … … 765 765 float64_u ua; 766 766 ua.val = a; 767 767 768 768 float64_u ub; 769 769 ub.val = b; 770 770 771 771 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 772 772 /* No special constant for unordered - maybe signaled? */ 773 773 return 1; 774 774 } 775 775 776 776 if (is_float64_eq(ua.data, ub.data)) 777 777 return 0; 778 778 779 779 if (is_float64_lt(ua.data, ub.data)) 780 780 return -1; 781 781 782 782 return 1; 783 783 } … … 787 787 float64_u ua; 788 788 ua.val = a; 789 789 790 790 float64_u ub; 791 791 ub.val = b; 792 792 793 793 return ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))); 794 794 } … … 798 798 float64_u ua; 799 799 ua.val = a; 800 800 801 801 float64_u ub; 802 802 ub.val = b; 803 803 804 804 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 805 805 // TODO: sigNaNs 806 806 return 1; 807 807 } 808 808 809 809 if (is_float64_lt(ua.data, ub.data)) 810 810 return -1; 811 811 812 812 return 0; 813 813 } … … 817 817 float64_u ua; 818 818 ua.val = a; 819 819 820 820 float64_u ub; 821 821 ub.val = b; 822 822 823 823 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 824 824 // TODO: sigNaNs 825 825 return 1; 826 826 } 827 827 828 828 return is_float64_eq(ua.data, ub.data) - 1; 829 829 } … … 833 833 float64_u ua; 834 834 ua.val = a; 835 835 836 836 float64_u ub; 837 837 ub.val = b; 838 838 839 839 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 840 840 // TODO: sigNaNs 841 841 return -1; 842 842 } 843 843 844 844 if (is_float64_gt(ua.data, ub.data)) 845 845 return 1; 846 846 847 847 return 0; 848 848 } … … 852 852 float64_u ua; 853 853 ua.val = a; 854 854 855 855 float64_u ub; 856 856 ub.val = b; 857 857 858 858 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 859 859 // TODO: sigNaNs 860 860 return -1; 861 861 } 862 862 863 863 if (is_float64_eq(ua.data, ub.data)) 864 864 return 0; 865 865 866 866 if (is_float64_gt(ua.data, ub.data)) 867 867 return 1; 868 868 869 869 return -1; 870 870 } … … 874 874 float64_u ua; 875 875 ua.val = a; 876 876 877 877 float64_u ub; 878 878 ub.val = b; 879 879 880 880 if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { 881 881 // TODO: sigNaNs 882 882 return 1; 883 883 } 884 884 885 885 if (is_float64_eq(ua.data, ub.data)) 886 886 return 0; 887 887 888 888 if (is_float64_lt(ua.data, ub.data)) 889 889 return -1; 890 890 891 891 return 1; 892 892 } … … 900 900 float128_u ua; 901 901 ua.val = a; 902 903 float128_u ub; 904 ub.val = b; 905 902 903 float128_u ub; 904 ub.val = b; 905 906 906 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { 907 907 // TODO: sigNaNs 908 908 return -1; 909 909 } 910 910 911 911 if (is_float128_gt(ua.data, ub.data)) 912 912 return 1; 913 913 914 914 return 0; 915 915 } … … 919 919 float128_u ua; 920 920 ua.val = a; 921 922 float128_u ub; 923 ub.val = b; 924 921 922 float128_u ub; 923 ub.val = b; 924 925 925 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { 926 926 // TODO: sigNaNs 927 927 return -1; 928 928 } 929 929 930 930 if (is_float128_eq(ua.data, ub.data)) 931 931 return 0; 932 932 933 933 if (is_float128_gt(ua.data, ub.data)) 934 934 return 1; 935 935 936 936 return -1; 937 937 } … … 941 941 float128_u ua; 942 942 ua.val = a; 943 944 float128_u ub; 945 ub.val = b; 946 943 944 float128_u ub; 945 ub.val = b; 946 947 947 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { 948 948 // TODO: sigNaNs 949 949 return 1; 950 950 } 951 951 952 952 if (is_float128_lt(ua.data, ub.data)) 953 953 return -1; 954 954 955 955 return 0; 956 956 } … … 960 960 float128_u ua; 961 961 ua.val = a; 962 963 float128_u ub; 964 ub.val = b; 965 962 963 float128_u ub; 964 ub.val = b; 965 966 966 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { 967 967 // TODO: sigNaNs 968 968 return 1; 969 969 } 970 970 971 971 if (is_float128_eq(ua.data, ub.data)) 972 972 return 0; 973 973 974 974 if (is_float128_lt(ua.data, ub.data)) 975 975 return -1; 976 976 977 977 return 1; 978 978 } … … 982 982 float128_u ua; 983 983 ua.val = a; 984 985 float128_u ub; 986 ub.val = b; 987 984 985 float128_u ub; 986 ub.val = b; 987 988 988 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { 989 989 // TODO: sigNaNs 990 990 return 1; 991 991 } 992 992 993 993 return is_float128_eq(ua.data, ub.data) - 1; 994 994 } … … 1004 1004 float128_u ua; 1005 1005 ua.val = a; 1006 1007 float128_u ub; 1008 ub.val = b; 1009 1006 1007 float128_u ub; 1008 ub.val = b; 1009 1010 1010 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { 1011 1011 /* No special constant for unordered - maybe signaled? */ 1012 1012 return 1; 1013 1013 } 1014 1014 1015 1015 if (is_float128_eq(ua.data, ub.data)) 1016 1016 return 0; 1017 1017 1018 1018 if (is_float128_lt(ua.data, ub.data)) 1019 1019 return -1; 1020 1020 1021 1021 return 1; 1022 1022 } … … 1026 1026 float128_u ua; 1027 1027 ua.val = a; 1028 1029 float128_u ub; 1030 ub.val = b; 1031 1028 1029 float128_u ub; 1030 ub.val = b; 1031 1032 1032 return ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))); 1033 1033 } … … 1037 1037 float128_u ua; 1038 1038 ua.val = *a; 1039 1039 1040 1040 float128_u ub; 1041 1041 ub.val = *b; 1042 1042 1043 1043 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) 1044 1044 return 3; 1045 1045 1046 1046 if (is_float128_eq(ua.data, ub.data)) 1047 1047 return 0; 1048 1048 1049 1049 if (is_float128_lt(ua.data, ub.data)) 1050 1050 return 1; 1051 1051 1052 1052 return 2; 1053 1053 } … … 1063 1063 float128_u ua; 1064 1064 ua.val = *a; 1065 1065 1066 1066 float128_u ub; 1067 1067 ub.val = *b; 1068 1068 1069 1069 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) 1070 1070 return 0; 1071 1071 1072 1072 return is_float128_gt(ua.data, ub.data); 1073 1073 } … … 1077 1077 float128_u ua; 1078 1078 ua.val = *a; 1079 1079 1080 1080 float128_u ub; 1081 1081 ub.val = *b; 1082 1082 1083 1083 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) 1084 1084 return 0; 1085 1085 1086 1086 return is_float128_eq(ua.data, ub.data) || 1087 1087 is_float128_gt(ua.data, ub.data); … … 1092 1092 float128_u ua; 1093 1093 ua.val = *a; 1094 1094 1095 1095 float128_u ub; 1096 1096 ub.val = *b; 1097 1097 1098 1098 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) 1099 1099 return 0; 1100 1100 1101 1101 return is_float128_lt(ua.data, ub.data); 1102 1102 } … … 1106 1106 float128_u ua; 1107 1107 ua.val = *a; 1108 1108 1109 1109 float128_u ub; 1110 1110 ub.val = *b; 1111 1111 1112 1112 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) 1113 1113 return 0; 1114 1114 1115 1115 return is_float128_eq(ua.data, ub.data) || 1116 1116 is_float128_lt(ua.data, ub.data); … … 1121 1121 float128_u ua; 1122 1122 ua.val = *a; 1123 1123 1124 1124 float128_u ub; 1125 1125 ub.val = *b; 1126 1126 1127 1127 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) 1128 1128 return 0; 1129 1129 1130 1130 return is_float128_eq(ua.data, ub.data); 1131 1131 } … … 1135 1135 float128_u ua; 1136 1136 ua.val = *a; 1137 1137 1138 1138 float128_u ub; 1139 1139 ub.val = *b; 1140 1140 1141 1141 if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) 1142 1142 return 0; 1143 1143 1144 1144 return !is_float128_eq(ua.data, ub.data); 1145 1145 } -
uspace/lib/softfloat/conversion.c
r3061bc1 ra35b458 42 42 float64 result; 43 43 uint64_t frac; 44 44 45 45 result.parts.sign = a.parts.sign; 46 46 result.parts.fraction = a.parts.fraction; 47 47 result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); 48 48 49 49 if ((is_float32_infinity(a)) || (is_float32_nan(a))) { 50 50 result.parts.exp = FLOAT64_MAX_EXPONENT; … … 52 52 return result; 53 53 } 54 54 55 55 result.parts.exp = a.parts.exp + ((int) FLOAT64_BIAS - FLOAT32_BIAS); 56 56 if (a.parts.exp == 0) { 57 57 /* normalize denormalized numbers */ 58 58 59 59 if (result.parts.fraction == 0) { /* fix zero */ 60 60 result.parts.exp = 0; 61 61 return result; 62 62 } 63 63 64 64 frac = result.parts.fraction; 65 65 66 66 while (!(frac & FLOAT64_HIDDEN_BIT_MASK)) { 67 67 frac <<= 1; 68 68 --result.parts.exp; 69 69 } 70 70 71 71 ++result.parts.exp; 72 72 result.parts.fraction = frac; 73 73 } 74 74 75 75 return result; 76 76 } … … 81 81 uint64_t frac_hi, frac_lo; 82 82 uint64_t tmp_hi, tmp_lo; 83 83 84 84 result.parts.sign = a.parts.sign; 85 85 result.parts.frac_hi = 0; … … 90 90 result.parts.frac_hi = frac_hi; 91 91 result.parts.frac_lo = frac_lo; 92 92 93 93 if ((is_float32_infinity(a)) || (is_float32_nan(a))) { 94 94 result.parts.exp = FLOAT128_MAX_EXPONENT; … … 96 96 return result; 97 97 } 98 98 99 99 result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS); 100 100 if (a.parts.exp == 0) { 101 101 /* normalize denormalized numbers */ 102 102 103 103 if (eq128(result.parts.frac_hi, 104 104 result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */ … … 106 106 return result; 107 107 } 108 108 109 109 frac_hi = result.parts.frac_hi; 110 110 frac_lo = result.parts.frac_lo; 111 111 112 112 and128(frac_hi, frac_lo, 113 113 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, … … 117 117 --result.parts.exp; 118 118 } 119 119 120 120 ++result.parts.exp; 121 121 result.parts.frac_hi = frac_hi; 122 122 result.parts.frac_lo = frac_lo; 123 123 } 124 124 125 125 return result; 126 126 } … … 131 131 uint64_t frac_hi, frac_lo; 132 132 uint64_t tmp_hi, tmp_lo; 133 133 134 134 result.parts.sign = a.parts.sign; 135 135 result.parts.frac_hi = 0; … … 140 140 result.parts.frac_hi = frac_hi; 141 141 result.parts.frac_lo = frac_lo; 142 142 143 143 if ((is_float64_infinity(a)) || (is_float64_nan(a))) { 144 144 result.parts.exp = FLOAT128_MAX_EXPONENT; … … 146 146 return result; 147 147 } 148 148 149 149 result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS); 150 150 if (a.parts.exp == 0) { 151 151 /* normalize denormalized numbers */ 152 152 153 153 if (eq128(result.parts.frac_hi, 154 154 result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */ … … 156 156 return result; 157 157 } 158 158 159 159 frac_hi = result.parts.frac_hi; 160 160 frac_lo = result.parts.frac_lo; 161 161 162 162 and128(frac_hi, frac_lo, 163 163 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, … … 167 167 --result.parts.exp; 168 168 } 169 169 170 170 ++result.parts.exp; 171 171 result.parts.frac_hi = frac_hi; 172 172 result.parts.frac_lo = frac_lo; 173 173 } 174 174 175 175 return result; 176 176 } … … 181 181 int32_t exp; 182 182 uint64_t frac; 183 183 184 184 result.parts.sign = a.parts.sign; 185 185 186 186 if (is_float64_nan(a)) { 187 187 result.parts.exp = FLOAT32_MAX_EXPONENT; 188 188 189 189 if (is_float64_signan(a)) { 190 190 /* set first bit of fraction nonzero */ … … 192 192 return result; 193 193 } 194 194 195 195 /* fraction nonzero but its first bit is zero */ 196 196 result.parts.fraction = 0x1; 197 197 return result; 198 198 } 199 199 200 200 if (is_float64_infinity(a)) { 201 201 result.parts.fraction = 0; … … 203 203 return result; 204 204 } 205 205 206 206 exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS; 207 207 208 208 if (exp >= FLOAT32_MAX_EXPONENT) { 209 209 /* FIXME: overflow */ … … 213 213 } else if (exp <= 0) { 214 214 /* underflow or denormalized */ 215 215 216 216 result.parts.exp = 0; 217 217 218 218 exp *= -1; 219 219 if (exp > FLOAT32_FRACTION_SIZE) { … … 222 222 return result; 223 223 } 224 224 225 225 /* denormalized */ 226 226 227 227 frac = a.parts.fraction; 228 228 frac |= FLOAT64_HIDDEN_BIT_MASK; /* denormalize and set hidden bit */ 229 229 230 230 frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1); 231 231 232 232 while (exp > 0) { 233 233 --exp; … … 235 235 } 236 236 result.parts.fraction = frac; 237 238 return result; 239 } 240 237 238 return result; 239 } 240 241 241 result.parts.exp = exp; 242 242 result.parts.fraction = … … 250 250 int32_t exp; 251 251 uint64_t frac_hi, frac_lo; 252 252 253 253 result.parts.sign = a.parts.sign; 254 254 255 255 if (is_float128_nan(a)) { 256 256 result.parts.exp = FLOAT32_MAX_EXPONENT; 257 257 258 258 if (is_float128_signan(a)) { 259 259 /* set first bit of fraction nonzero */ … … 261 261 return result; 262 262 } 263 263 264 264 /* fraction nonzero but its first bit is zero */ 265 265 result.parts.fraction = 0x1; 266 266 return result; 267 267 } 268 268 269 269 if (is_float128_infinity(a)) { 270 270 result.parts.fraction = 0; … … 272 272 return result; 273 273 } 274 274 275 275 exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS; 276 276 277 277 if (exp >= FLOAT32_MAX_EXPONENT) { 278 278 /* FIXME: overflow */ … … 282 282 } else if (exp <= 0) { 283 283 /* underflow or denormalized */ 284 284 285 285 result.parts.exp = 0; 286 286 287 287 exp *= -1; 288 288 if (exp > FLOAT32_FRACTION_SIZE) { … … 291 291 return result; 292 292 } 293 293 294 294 /* denormalized */ 295 295 296 296 frac_hi = a.parts.frac_hi; 297 297 frac_lo = a.parts.frac_lo; 298 298 299 299 /* denormalize and set hidden bit */ 300 300 frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; 301 301 302 302 rshift128(frac_hi, frac_lo, 303 303 (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1), 304 304 &frac_hi, &frac_lo); 305 305 306 306 while (exp > 0) { 307 307 --exp; … … 309 309 } 310 310 result.parts.fraction = frac_lo; 311 312 return result; 313 } 314 311 312 return result; 313 } 314 315 315 result.parts.exp = exp; 316 316 frac_hi = a.parts.frac_hi; … … 328 328 int32_t exp; 329 329 uint64_t frac_hi, frac_lo; 330 330 331 331 result.parts.sign = a.parts.sign; 332 332 333 333 if (is_float128_nan(a)) { 334 334 result.parts.exp = FLOAT64_MAX_EXPONENT; 335 335 336 336 if (is_float128_signan(a)) { 337 337 /* set first bit of fraction nonzero */ … … 339 339 return result; 340 340 } 341 341 342 342 /* fraction nonzero but its first bit is zero */ 343 343 result.parts.fraction = 0x1; 344 344 return result; 345 345 } 346 346 347 347 if (is_float128_infinity(a)) { 348 348 result.parts.fraction = 0; … … 350 350 return result; 351 351 } 352 352 353 353 exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS; 354 354 355 355 if (exp >= FLOAT64_MAX_EXPONENT) { 356 356 /* FIXME: overflow */ … … 360 360 } else if (exp <= 0) { 361 361 /* underflow or denormalized */ 362 362 363 363 result.parts.exp = 0; 364 364 365 365 exp *= -1; 366 366 if (exp > FLOAT64_FRACTION_SIZE) { … … 369 369 return result; 370 370 } 371 371 372 372 /* denormalized */ 373 373 374 374 frac_hi = a.parts.frac_hi; 375 375 frac_lo = a.parts.frac_lo; 376 376 377 377 /* denormalize and set hidden bit */ 378 378 frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; 379 379 380 380 rshift128(frac_hi, frac_lo, 381 381 (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1), 382 382 &frac_hi, &frac_lo); 383 383 384 384 while (exp > 0) { 385 385 --exp; … … 387 387 } 388 388 result.parts.fraction = frac_lo; 389 390 return result; 391 } 392 389 390 return result; 391 } 392 393 393 result.parts.exp = exp; 394 394 frac_hi = a.parts.frac_hi; … … 410 410 { 411 411 uint32_t frac; 412 412 413 413 if (a.parts.exp < FLOAT32_BIAS) { 414 414 /* TODO: rounding */ 415 415 return 0; 416 416 } 417 417 418 418 frac = a.parts.fraction; 419 419 420 420 frac |= FLOAT32_HIDDEN_BIT_MASK; 421 421 /* shift fraction to left so hidden bit will be the most significant bit */ 422 422 frac <<= 32 - FLOAT32_FRACTION_SIZE - 1; 423 423 424 424 frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1; 425 425 if ((a.parts.sign == 1) && (frac != 0)) { … … 427 427 ++frac; 428 428 } 429 429 430 430 return frac; 431 431 } … … 439 439 if (is_float32_nan(a)) 440 440 return UINT32_MAX; 441 441 442 442 if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { 443 443 if (a.parts.sign) 444 444 return UINT32_MIN; 445 445 446 446 return UINT32_MAX; 447 447 } 448 448 449 449 return _float32_to_uint32_helper(a); 450 450 } … … 458 458 if (is_float32_nan(a)) 459 459 return INT32_MAX; 460 460 461 461 if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { 462 462 if (a.parts.sign) 463 463 return INT32_MIN; 464 464 465 465 return INT32_MAX; 466 466 } 467 467 468 468 return _float32_to_uint32_helper(a); 469 469 } … … 478 478 { 479 479 uint64_t frac; 480 480 481 481 if (a.parts.exp < FLOAT32_BIAS) { 482 482 // TODO: rounding 483 483 return 0; 484 484 } 485 485 486 486 frac = a.parts.fraction; 487 487 488 488 frac |= FLOAT32_HIDDEN_BIT_MASK; 489 489 /* shift fraction to left so hidden bit will be the most significant bit */ 490 490 frac <<= 64 - FLOAT32_FRACTION_SIZE - 1; 491 491 492 492 frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1; 493 493 if ((a.parts.sign == 1) && (frac != 0)) { … … 495 495 ++frac; 496 496 } 497 497 498 498 return frac; 499 499 } … … 507 507 if (is_float32_nan(a)) 508 508 return UINT64_MAX; 509 509 510 510 if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { 511 511 if (a.parts.sign) 512 512 return UINT64_MIN; 513 513 514 514 return UINT64_MAX; 515 515 } 516 516 517 517 return _float32_to_uint64_helper(a); 518 518 } … … 526 526 if (is_float32_nan(a)) 527 527 return INT64_MAX; 528 528 529 529 if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { 530 530 if (a.parts.sign) 531 531 return INT64_MIN; 532 532 533 533 return INT64_MAX; 534 534 } 535 535 536 536 return _float32_to_uint64_helper(a); 537 537 } … … 546 546 { 547 547 uint64_t frac; 548 548 549 549 if (a.parts.exp < FLOAT64_BIAS) { 550 550 // TODO: rounding 551 551 return 0; 552 552 } 553 553 554 554 frac = a.parts.fraction; 555 555 556 556 frac |= FLOAT64_HIDDEN_BIT_MASK; 557 557 /* shift fraction to left so hidden bit will be the most significant bit */ 558 558 frac <<= 64 - FLOAT64_FRACTION_SIZE - 1; 559 559 560 560 frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1; 561 561 if ((a.parts.sign == 1) && (frac != 0)) { … … 563 563 ++frac; 564 564 } 565 565 566 566 return frac; 567 567 } … … 575 575 if (is_float64_nan(a)) 576 576 return UINT32_MAX; 577 577 578 578 if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { 579 579 if (a.parts.sign) 580 580 return UINT32_MIN; 581 581 582 582 return UINT32_MAX; 583 583 } 584 584 585 585 return (uint32_t) _float64_to_uint64_helper(a); 586 586 } … … 594 594 if (is_float64_nan(a)) 595 595 return INT32_MAX; 596 596 597 597 if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { 598 598 if (a.parts.sign) 599 599 return INT32_MIN; 600 600 601 601 return INT32_MAX; 602 602 } 603 603 604 604 return (int32_t) _float64_to_uint64_helper(a); 605 605 } … … 613 613 if (is_float64_nan(a)) 614 614 return UINT64_MAX; 615 615 616 616 if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { 617 617 if (a.parts.sign) 618 618 return UINT64_MIN; 619 619 620 620 return UINT64_MAX; 621 621 } 622 622 623 623 return _float64_to_uint64_helper(a); 624 624 } … … 632 632 if (is_float64_nan(a)) 633 633 return INT64_MAX; 634 634 635 635 if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { 636 636 if (a.parts.sign) 637 637 return INT64_MIN; 638 638 639 639 return INT64_MAX; 640 640 } 641 641 642 642 return _float64_to_uint64_helper(a); 643 643 } … … 652 652 { 653 653 uint64_t frac_hi, frac_lo; 654 654 655 655 if (a.parts.exp < FLOAT128_BIAS) { 656 656 // TODO: rounding 657 657 return 0; 658 658 } 659 659 660 660 frac_hi = a.parts.frac_hi; 661 661 frac_lo = a.parts.frac_lo; 662 662 663 663 frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; 664 664 /* shift fraction to left so hidden bit will be the most significant bit */ 665 665 lshift128(frac_hi, frac_lo, 666 666 (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo); 667 667 668 668 rshift128(frac_hi, frac_lo, 669 669 (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo); … … 672 672 add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo); 673 673 } 674 674 675 675 return frac_lo; 676 676 } … … 684 684 if (is_float128_nan(a)) 685 685 return UINT32_MAX; 686 686 687 687 if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { 688 688 if (a.parts.sign) 689 689 return UINT32_MIN; 690 690 691 691 return UINT32_MAX; 692 692 } 693 693 694 694 return (uint32_t) _float128_to_uint64_helper(a); 695 695 } … … 703 703 if (is_float128_nan(a)) 704 704 return INT32_MAX; 705 705 706 706 if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { 707 707 if (a.parts.sign) 708 708 return INT32_MIN; 709 709 710 710 return INT32_MAX; 711 711 } 712 712 713 713 return (int32_t) _float128_to_uint64_helper(a); 714 714 } … … 722 722 if (is_float128_nan(a)) 723 723 return UINT64_MAX; 724 724 725 725 if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { 726 726 if (a.parts.sign) 727 727 return UINT64_MIN; 728 728 729 729 return UINT64_MAX; 730 730 } 731 731 732 732 return _float128_to_uint64_helper(a); 733 733 } … … 741 741 if (is_float128_nan(a)) 742 742 return INT64_MAX; 743 743 744 744 if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { 745 745 if (a.parts.sign) 746 746 return INT64_MIN; 747 747 748 748 return INT64_MAX; 749 749 } 750 750 751 751 return _float128_to_uint64_helper(a); 752 752 } … … 757 757 int32_t exp; 758 758 float32 result; 759 759 760 760 result.parts.sign = 0; 761 761 result.parts.fraction = 0; 762 762 763 763 counter = count_zeroes32(i); 764 764 765 765 exp = FLOAT32_BIAS + 32 - counter - 1; 766 766 767 767 if (counter == 32) { 768 768 result.bin = 0; 769 769 return result; 770 770 } 771 771 772 772 if (counter > 0) { 773 773 i <<= counter - 1; … … 775 775 i >>= 1; 776 776 } 777 777 778 778 round_float32(&exp, &i); 779 779 780 780 result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2); 781 781 result.parts.exp = exp; 782 782 783 783 return result; 784 784 } … … 787 787 { 788 788 float32 result; 789 789 790 790 if (i < 0) 791 791 result = uint32_to_float32((uint32_t) (-i)); 792 792 else 793 793 result = uint32_to_float32((uint32_t) i); 794 794 795 795 result.parts.sign = i < 0; 796 796 797 797 return result; 798 798 } … … 804 804 uint32_t j; 805 805 float32 result; 806 806 807 807 result.parts.sign = 0; 808 808 result.parts.fraction = 0; 809 809 810 810 counter = count_zeroes64(i); 811 811 812 812 exp = FLOAT32_BIAS + 64 - counter - 1; 813 813 814 814 if (counter == 64) { 815 815 result.bin = 0; 816 816 return result; 817 817 } 818 818 819 819 /* Shift all to the first 31 bits (31st will be hidden 1) */ 820 820 if (counter > 33) { … … 823 823 i >>= 1 + 32 - counter; 824 824 } 825 825 826 826 j = (uint32_t) i; 827 827 round_float32(&exp, &j); 828 828 829 829 result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2); 830 830 result.parts.exp = exp; … … 835 835 { 836 836 float32 result; 837 837 838 838 if (i < 0) 839 839 result = uint64_to_float32((uint64_t) (-i)); 840 840 else 841 841 result = uint64_to_float32((uint64_t) i); 842 842 843 843 result.parts.sign = i < 0; 844 844 845 845 return result; 846 846 } … … 852 852 float64 result; 853 853 uint64_t frac; 854 854 855 855 result.parts.sign = 0; 856 856 result.parts.fraction = 0; 857 857 858 858 counter = count_zeroes32(i); 859 859 860 860 exp = FLOAT64_BIAS + 32 - counter - 1; 861 861 862 862 if (counter == 32) { 863 863 result.bin = 0; 864 864 return result; 865 865 } 866 866 867 867 frac = i; 868 868 frac <<= counter + 32 - 1; 869 869 870 870 round_float64(&exp, &frac); 871 871 872 872 result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2); 873 873 result.parts.exp = exp; 874 874 875 875 return result; 876 876 } … … 879 879 { 880 880 float64 result; 881 881 882 882 if (i < 0) 883 883 result = uint32_to_float64((uint32_t) (-i)); 884 884 else 885 885 result = uint32_to_float64((uint32_t) i); 886 886 887 887 result.parts.sign = i < 0; 888 888 889 889 return result; 890 890 } … … 895 895 int32_t exp; 896 896 float64 result; 897 897 898 898 result.parts.sign = 0; 899 899 result.parts.fraction = 0; 900 900 901 901 counter = count_zeroes64(i); 902 902 903 903 exp = FLOAT64_BIAS + 64 - counter - 1; 904 904 905 905 if (counter == 64) { 906 906 result.bin = 0; 907 907 return result; 908 908 } 909 909 910 910 if (counter > 0) { 911 911 i <<= counter - 1; … … 913 913 i >>= 1; 914 914 } 915 915 916 916 round_float64(&exp, &i); 917 917 918 918 result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2); 919 919 result.parts.exp = exp; … … 924 924 { 925 925 float64 result; 926 926 927 927 if (i < 0) 928 928 result = uint64_to_float64((uint64_t) (-i)); 929 929 else 930 930 result = uint64_to_float64((uint64_t) i); 931 931 932 932 result.parts.sign = i < 0; 933 933 934 934 return result; 935 935 } … … 941 941 float128 result; 942 942 uint64_t frac_hi, frac_lo; 943 943 944 944 result.parts.sign = 0; 945 945 result.parts.frac_hi = 0; 946 946 result.parts.frac_lo = 0; 947 947 948 948 counter = count_zeroes32(i); 949 949 950 950 exp = FLOAT128_BIAS + 32 - counter - 1; 951 951 952 952 if (counter == 32) { 953 953 result.bin.hi = 0; … … 955 955 return result; 956 956 } 957 957 958 958 frac_hi = 0; 959 959 frac_lo = i; 960 960 lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo); 961 961 962 962 round_float128(&exp, &frac_hi, &frac_lo); 963 963 964 964 rshift128(frac_hi, frac_lo, 965 965 (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo); … … 967 967 result.parts.frac_lo = frac_lo; 968 968 result.parts.exp = exp; 969 969 970 970 return result; 971 971 } … … 974 974 { 975 975 float128 result; 976 976 977 977 if (i < 0) 978 978 result = uint32_to_float128((uint32_t) (-i)); 979 979 else 980 980 result = uint32_to_float128((uint32_t) i); 981 981 982 982 result.parts.sign = i < 0; 983 983 984 984 return result; 985 985 } … … 992 992 float128 result; 993 993 uint64_t frac_hi, frac_lo; 994 994 995 995 result.parts.sign = 0; 996 996 result.parts.frac_hi = 0; 997 997 result.parts.frac_lo = 0; 998 998 999 999 counter = count_zeroes64(i); 1000 1000 1001 1001 exp = FLOAT128_BIAS + 64 - counter - 1; 1002 1002 1003 1003 if (counter == 64) { 1004 1004 result.bin.hi = 0; … … 1006 1006 return result; 1007 1007 } 1008 1008 1009 1009 frac_hi = 0; 1010 1010 frac_lo = i; 1011 1011 lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo); 1012 1012 1013 1013 round_float128(&exp, &frac_hi, &frac_lo); 1014 1014 1015 1015 rshift128(frac_hi, frac_lo, 1016 1016 (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo); … … 1018 1018 result.parts.frac_lo = frac_lo; 1019 1019 result.parts.exp = exp; 1020 1020 1021 1021 return result; 1022 1022 } … … 1025 1025 { 1026 1026 float128 result; 1027 1027 1028 1028 if (i < 0) 1029 1029 result = uint64_to_float128((uint64_t) (-i)); 1030 1030 else 1031 1031 result = uint64_to_float128((uint64_t) i); 1032 1032 1033 1033 result.parts.sign = i < 0; 1034 1034 1035 1035 return result; 1036 1036 } … … 1042 1042 float32_u res; 1043 1043 res.data = int32_to_float32(i); 1044 1044 1045 1045 return res.val; 1046 1046 } … … 1050 1050 float32_u res; 1051 1051 res.data = int64_to_float32(i); 1052 1052 1053 1053 return res.val; 1054 1054 } … … 1058 1058 float32_u res; 1059 1059 res.data = uint32_to_float32(i); 1060 1060 1061 1061 return res.val; 1062 1062 } … … 1066 1066 float32_u res; 1067 1067 res.data = uint64_to_float32(i); 1068 1068 1069 1069 return res.val; 1070 1070 } … … 1074 1074 float32_u ua; 1075 1075 ua.val = a; 1076 1076 1077 1077 return float32_to_int32(ua.data); 1078 1078 } … … 1082 1082 float32_u ua; 1083 1083 ua.val = a; 1084 1084 1085 1085 return float32_to_int64(ua.data); 1086 1086 } … … 1090 1090 float32_u ua; 1091 1091 ua.val = a; 1092 1092 1093 1093 return float32_to_uint32(ua.data); 1094 1094 } … … 1098 1098 float32_u ua; 1099 1099 ua.val = a; 1100 1100 1101 1101 return float32_to_uint64(ua.data); 1102 1102 } … … 1106 1106 float32_u ua; 1107 1107 ua.val = a; 1108 1108 1109 1109 return float32_to_int32(ua.data); 1110 1110 } … … 1114 1114 float32_u ua; 1115 1115 ua.val = a; 1116 1116 1117 1117 return float32_to_uint32(ua.data); 1118 1118 } … … 1122 1122 float32_u res; 1123 1123 res.data = int32_to_float32(i); 1124 1124 1125 1125 return res.val; 1126 1126 } … … 1130 1130 float32_u res; 1131 1131 res.data = int64_to_float32(i); 1132 1132 1133 1133 return res.val; 1134 1134 } … … 1138 1138 float32_u res; 1139 1139 res.data = uint32_to_float32(i); 1140 1140 1141 1141 return res.val; 1142 1142 } … … 1146 1146 float32_u res; 1147 1147 res.data = uint64_to_float32(i); 1148 1148 1149 1149 return res.val; 1150 1150 } … … 1158 1158 float64_u res; 1159 1159 res.data = int32_to_float64(i); 1160 1160 1161 1161 return res.val; 1162 1162 } … … 1166 1166 float64_u res; 1167 1167 res.data = int64_to_float64(i); 1168 1168 1169 1169 return res.val; 1170 1170 } … … 1174 1174 float64_u res; 1175 1175 res.data = uint32_to_float64(i); 1176 1176 1177 1177 return res.val; 1178 1178 } … … 1182 1182 float64_u res; 1183 1183 res.data = uint64_to_float64(i); 1184 1184 1185 1185 return res.val; 1186 1186 } … … 1190 1190 float64_u ua; 1191 1191 ua.val = a; 1192 1192 1193 1193 return float64_to_uint32(ua.data); 1194 1194 } … … 1198 1198 float64_u ua; 1199 1199 ua.val = a; 1200 1200 1201 1201 return float64_to_uint64(ua.data); 1202 1202 } … … 1206 1206 float64_u ua; 1207 1207 ua.val = a; 1208 1208 1209 1209 return float64_to_int32(ua.data); 1210 1210 } … … 1214 1214 float64_u ua; 1215 1215 ua.val = a; 1216 1216 1217 1217 return float64_to_int64(ua.data); 1218 1218 } … … 1222 1222 float64_u res; 1223 1223 res.data = int32_to_float64(i); 1224 1224 1225 1225 return res.val; 1226 1226 } … … 1230 1230 float64_u res; 1231 1231 res.data = uint32_to_float64(i); 1232 1232 1233 1233 return res.val; 1234 1234 } … … 1238 1238 float64_u res; 1239 1239 res.data = int64_to_float64(i); 1240 1240 1241 1241 return res.val; 1242 1242 } … … 1246 1246 float64_u ua; 1247 1247 ua.val = a; 1248 1248 1249 1249 return float64_to_int32(ua.data); 1250 1250 } … … 1254 1254 float64_u ua; 1255 1255 ua.val = a; 1256 1256 1257 1257 return float64_to_int64(ua.data); 1258 1258 } … … 1262 1262 float64_u ua; 1263 1263 ua.val = a; 1264 1264 1265 1265 return float64_to_uint32(ua.data); 1266 1266 } … … 1274 1274 float128_u res; 1275 1275 res.data = int32_to_float128(i); 1276 1276 1277 1277 return res.val; 1278 1278 } … … 1282 1282 float128_u res; 1283 1283 res.data = int64_to_float128(i); 1284 1284 1285 1285 return res.val; 1286 1286 } … … 1290 1290 float128_u res; 1291 1291 res.data = uint32_to_float128(i); 1292 1292 1293 1293 return res.val; 1294 1294 } … … 1298 1298 float128_u res; 1299 1299 res.data = uint64_to_float128(i); 1300 1300 1301 1301 return res.val; 1302 1302 } … … 1306 1306 float128_u ua; 1307 1307 ua.val = a; 1308 1308 1309 1309 return float128_to_int32(ua.data); 1310 1310 } … … 1314 1314 float128_u ua; 1315 1315 ua.val = a; 1316 1316 1317 1317 return float128_to_uint64(ua.data); 1318 1318 } … … 1322 1322 float128_u ua; 1323 1323 ua.val = a; 1324 1324 1325 1325 return float128_to_uint32(ua.data); 1326 1326 } … … 1330 1330 float128_u ua; 1331 1331 ua.val = a; 1332 1332 1333 1333 return float128_to_uint64(ua.data); 1334 1334 } … … 1382 1382 float64_u ua; 1383 1383 ua.val = a; 1384 1384 1385 1385 float32_u res; 1386 1386 res.data = float64_to_float32(ua.data); 1387 1387 1388 1388 return res.val; 1389 1389 } … … 1393 1393 float32_u ua; 1394 1394 ua.val = a; 1395 1395 1396 1396 float64_u res; 1397 1397 res.data = float32_to_float64(ua.data); 1398 1398 1399 1399 return res.val; 1400 1400 } … … 1404 1404 float32_u ua; 1405 1405 ua.val = a; 1406 1406 1407 1407 float64_u res; 1408 1408 res.data = float32_to_float64(ua.data); 1409 1409 1410 1410 return res.val; 1411 1411 } … … 1415 1415 float64_u ua; 1416 1416 ua.val = a; 1417 1417 1418 1418 float32_u res; 1419 1419 res.data = float64_to_float32(ua.data); 1420 1420 1421 1421 return res.val; 1422 1422 } … … 1430 1430 float128_u ua; 1431 1431 ua.val = a; 1432 1432 1433 1433 float32_u res; 1434 1434 res.data = float128_to_float32(ua.data); 1435 1435 1436 1436 return res.val; 1437 1437 } … … 1441 1441 float32_u ua; 1442 1442 ua.val = a; 1443 1443 1444 1444 float128_u res; 1445 1445 res.data = float32_to_float128(ua.data); 1446 1446 1447 1447 return res.val; 1448 1448 } … … 1466 1466 float128_u ua; 1467 1467 ua.val = a; 1468 1468 1469 1469 float64_u res; 1470 1470 res.data = float128_to_float64(ua.data); 1471 1471 1472 1472 return res.val; 1473 1473 } … … 1477 1477 float64_u ua; 1478 1478 ua.val = a; 1479 1479 1480 1480 float128_u res; 1481 1481 res.data = float64_to_float128(ua.data); 1482 1482 1483 1483 return res.val; 1484 1484 } -
uspace/lib/softfloat/div.c
r3061bc1 ra35b458 53 53 int32_t aexp, bexp, cexp; 54 54 uint64_t afrac, bfrac, cfrac; 55 55 56 56 result.parts.sign = a.parts.sign ^ b.parts.sign; 57 57 58 58 if (is_float32_nan(a)) { 59 59 if (is_float32_signan(a)) { … … 63 63 return a; 64 64 } 65 65 66 66 if (is_float32_nan(b)) { 67 67 if (is_float32_signan(b)) { … … 71 71 return b; 72 72 } 73 73 74 74 if (is_float32_infinity(a)) { 75 75 if (is_float32_infinity(b)) { … … 83 83 return result; 84 84 } 85 85 86 86 if (is_float32_infinity(b)) { 87 87 if (is_float32_zero(a)) { … … 96 96 return result; 97 97 } 98 98 99 99 if (is_float32_zero(b)) { 100 100 if (is_float32_zero(a)) { … … 108 108 return result; 109 109 } 110 110 111 111 afrac = a.parts.fraction; 112 112 aexp = a.parts.exp; 113 113 bfrac = b.parts.fraction; 114 114 bexp = b.parts.exp; 115 115 116 116 /* denormalized numbers */ 117 117 if (aexp == 0) { … … 121 121 return result; 122 122 } 123 123 124 124 /* normalize it*/ 125 125 afrac <<= 1; … … 130 130 } 131 131 } 132 132 133 133 if (bexp == 0) { 134 134 bfrac <<= 1; … … 139 139 } 140 140 } 141 141 142 142 afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1); 143 143 bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE); 144 144 145 145 if (bfrac <= (afrac << 1)) { 146 146 afrac >>= 1; 147 147 aexp++; 148 148 } 149 149 150 150 cexp = aexp - bexp + FLOAT32_BIAS - 2; 151 151 152 152 cfrac = (afrac << 32) / bfrac; 153 153 if ((cfrac & 0x3F) == 0) { 154 154 cfrac |= (bfrac * cfrac != afrac << 32); 155 155 } 156 156 157 157 /* pack and round */ 158 158 159 159 /* find first nonzero digit and shift result and detect possibly underflow */ 160 160 while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)))) { … … 163 163 /* TODO: fix underflow */ 164 164 } 165 165 166 166 cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/ 167 167 168 168 if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) { 169 169 ++cexp; 170 170 cfrac >>= 1; 171 171 } 172 172 173 173 /* check overflow */ 174 174 if (cexp >= FLOAT32_MAX_EXPONENT) { … … 178 178 return result; 179 179 } 180 180 181 181 if (cexp < 0) { 182 182 /* FIXME: underflow */ … … 194 194 result.parts.exp = (uint32_t) cexp; 195 195 } 196 196 197 197 result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 198 198 199 199 return result; 200 200 } … … 215 215 uint64_t remlo, remhi; 216 216 uint64_t tmplo, tmphi; 217 217 218 218 result.parts.sign = a.parts.sign ^ b.parts.sign; 219 219 220 220 if (is_float64_nan(a)) { 221 221 if (is_float64_signan(b)) { … … 223 223 return b; 224 224 } 225 225 226 226 if (is_float64_signan(a)) { 227 227 // FIXME: SigNaN … … 230 230 return a; 231 231 } 232 232 233 233 if (is_float64_nan(b)) { 234 234 if (is_float64_signan(b)) { … … 238 238 return b; 239 239 } 240 240 241 241 if (is_float64_infinity(a)) { 242 242 if (is_float64_infinity(b) || is_float64_zero(b)) { … … 250 250 return result; 251 251 } 252 252 253 253 if (is_float64_infinity(b)) { 254 254 if (is_float64_zero(a)) { … … 263 263 return result; 264 264 } 265 265 266 266 if (is_float64_zero(b)) { 267 267 if (is_float64_zero(a)) { … … 275 275 return result; 276 276 } 277 277 278 278 afrac = a.parts.fraction; 279 279 aexp = a.parts.exp; 280 280 bfrac = b.parts.fraction; 281 281 bexp = b.parts.exp; 282 282 283 283 /* denormalized numbers */ 284 284 if (aexp == 0) { … … 288 288 return result; 289 289 } 290 290 291 291 /* normalize it*/ 292 292 aexp++; … … 297 297 } 298 298 } 299 299 300 300 if (bexp == 0) { 301 301 bexp++; … … 306 306 } 307 307 } 308 308 309 309 afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2); 310 310 bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1); 311 311 312 312 if (bfrac <= (afrac << 1)) { 313 313 afrac >>= 1; 314 314 aexp++; 315 315 } 316 316 317 317 cexp = aexp - bexp + FLOAT64_BIAS - 2; 318 318 319 319 cfrac = div128est(afrac, 0x0ll, bfrac); 320 320 321 321 if ((cfrac & 0x1FF) <= 2) { 322 322 mul64(bfrac, cfrac, &tmphi, &tmplo); 323 323 sub128(afrac, 0x0ll, tmphi, tmplo, &remhi, &remlo); 324 324 325 325 while ((int64_t) remhi < 0) { 326 326 cfrac--; … … 329 329 cfrac |= (remlo != 0); 330 330 } 331 331 332 332 /* round and shift */ 333 333 result = finish_float64(cexp, cfrac, result.parts.sign); … … 351 351 uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo; 352 352 uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo; 353 353 354 354 result.parts.sign = a.parts.sign ^ b.parts.sign; 355 355 356 356 if (is_float128_nan(a)) { 357 357 if (is_float128_signan(b)) { … … 359 359 return b; 360 360 } 361 361 362 362 if (is_float128_signan(a)) { 363 363 // FIXME: SigNaN … … 366 366 return a; 367 367 } 368 368 369 369 if (is_float128_nan(b)) { 370 370 if (is_float128_signan(b)) { … … 374 374 return b; 375 375 } 376 376 377 377 if (is_float128_infinity(a)) { 378 378 if (is_float128_infinity(b) || is_float128_zero(b)) { … … 388 388 return result; 389 389 } 390 390 391 391 if (is_float128_infinity(b)) { 392 392 if (is_float128_zero(a)) { … … 403 403 return result; 404 404 } 405 405 406 406 if (is_float128_zero(b)) { 407 407 if (is_float128_zero(a)) { … … 417 417 return result; 418 418 } 419 419 420 420 afrac_hi = a.parts.frac_hi; 421 421 afrac_lo = a.parts.frac_lo; … … 424 424 bfrac_lo = b.parts.frac_lo; 425 425 bexp = b.parts.exp; 426 426 427 427 /* denormalized numbers */ 428 428 if (aexp == 0) { … … 433 433 return result; 434 434 } 435 435 436 436 /* normalize it*/ 437 437 aexp++; … … 445 445 } 446 446 } 447 447 448 448 if (bexp == 0) { 449 449 bexp++; … … 457 457 } 458 458 } 459 459 460 460 or128(afrac_hi, afrac_lo, 461 461 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, … … 468 468 lshift128(bfrac_hi, bfrac_lo, 469 469 (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo); 470 470 471 471 if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) { 472 472 rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo); 473 473 aexp++; 474 474 } 475 475 476 476 cexp = aexp - bexp + FLOAT128_BIAS - 2; 477 477 478 478 cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi); 479 479 480 480 mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi, 481 481 &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi); 482 482 483 483 /* sub192(afrac_hi, afrac_lo, 0, 484 484 * tmp_hihi, tmp_hilo, tmp_lohi … … 489 489 } 490 490 rem_lohi = -tmp_lohi; 491 491 492 492 while ((int64_t) rem_hihi < 0) { 493 493 --cfrac_hi; … … 500 500 } 501 501 } 502 502 503 503 cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo); 504 504 505 505 if ((cfrac_lo & 0x3FFF) <= 4) { 506 506 mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo, 507 507 &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo); 508 508 509 509 /* sub192(rem_hilo, rem_lohi, 0, 510 510 * tmp_hilo, tmp_lohi, tmp_lolo, … … 515 515 } 516 516 rem_lolo = -tmp_lolo; 517 517 518 518 while ((int64_t) rem_hilo < 0) { 519 519 --cfrac_lo; … … 526 526 } 527 527 } 528 528 529 529 cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 ); 530 530 } 531 531 532 532 shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1)); 533 533 rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1), 534 534 &cfrac_hi, &cfrac_lo); 535 535 536 536 result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out); 537 537 return result; … … 544 544 float32_u ua; 545 545 ua.val = a; 546 546 547 547 float32_u ub; 548 548 ub.val = b; 549 549 550 550 float32_u res; 551 551 res.data = div_float32(ua.data, ub.data); 552 552 553 553 return res.val; 554 554 } … … 558 558 float32_u ua; 559 559 ua.val = a; 560 560 561 561 float32_u ub; 562 562 ub.val = b; 563 563 564 564 float32_u res; 565 565 res.data = div_float32(ua.data, ub.data); 566 566 567 567 return res.val; 568 568 } … … 576 576 float64_u ua; 577 577 ua.val = a; 578 578 579 579 float64_u ub; 580 580 ub.val = b; 581 581 582 582 float64_u res; 583 583 res.data = div_float64(ua.data, ub.data); 584 584 585 585 return res.val; 586 586 } … … 590 590 float64_u ua; 591 591 ua.val = a; 592 592 593 593 float64_u ub; 594 594 ub.val = b; 595 595 596 596 float64_u res; 597 597 res.data = div_float64(ua.data, ub.data); 598 598 599 599 return res.val; 600 600 } … … 608 608 float128_u ua; 609 609 ua.val = a; 610 610 611 611 float128_u ub; 612 612 ub.val = b; 613 613 614 614 float128_u res; 615 615 res.data = div_float128(ua.data, ub.data); 616 616 617 617 return res.val; 618 618 } -
uspace/lib/softfloat/mul.c
r3061bc1 ra35b458 51 51 uint64_t frac1, frac2; 52 52 int32_t exp; 53 53 54 54 result.parts.sign = a.parts.sign ^ b.parts.sign; 55 55 56 56 if (is_float32_nan(a) || is_float32_nan(b)) { 57 57 /* TODO: fix SigNaNs */ … … 61 61 return result; 62 62 } 63 63 64 64 if (is_float32_signan(b)) { /* TODO: fix SigNaN */ 65 65 result.parts.fraction = b.parts.fraction; … … 67 67 return result; 68 68 } 69 69 70 70 /* set NaN as result */ 71 71 result.bin = FLOAT32_NAN; 72 72 return result; 73 73 } 74 74 75 75 if (is_float32_infinity(a)) { 76 76 if (is_float32_zero(b)) { … … 79 79 return result; 80 80 } 81 81 82 82 result.parts.fraction = a.parts.fraction; 83 83 result.parts.exp = a.parts.exp; 84 84 return result; 85 85 } 86 86 87 87 if (is_float32_infinity(b)) { 88 88 if (is_float32_zero(a)) { … … 91 91 return result; 92 92 } 93 93 94 94 result.parts.fraction = b.parts.fraction; 95 95 result.parts.exp = b.parts.exp; 96 96 return result; 97 97 } 98 98 99 99 /* exp is signed so we can easy detect underflow */ 100 100 exp = a.parts.exp + b.parts.exp; 101 101 exp -= FLOAT32_BIAS; 102 102 103 103 if (exp >= FLOAT32_MAX_EXPONENT) { 104 104 /* FIXME: overflow */ … … 108 108 return result; 109 109 } 110 110 111 111 if (exp < 0) { 112 112 /* FIXME: underflow */ … … 116 116 return result; 117 117 } 118 118 119 119 frac1 = a.parts.fraction; 120 120 if (a.parts.exp > 0) { … … 123 123 ++exp; 124 124 } 125 125 126 126 frac2 = b.parts.fraction; 127 127 128 128 if (b.parts.exp > 0) { 129 129 frac2 |= FLOAT32_HIDDEN_BIT_MASK; … … 131 131 ++exp; 132 132 } 133 133 134 134 frac1 <<= 1; /* one bit space for rounding */ 135 135 136 136 frac1 = frac1 * frac2; 137 137 138 138 /* round and return */ 139 139 while ((exp < FLOAT32_MAX_EXPONENT) && … … 143 143 frac1 >>= 1; 144 144 } 145 145 146 146 /* rounding */ 147 147 /* ++frac1; FIXME: not works - without it is ok */ 148 148 frac1 >>= 1; /* shift off rounding space */ 149 149 150 150 if ((exp < FLOAT32_MAX_EXPONENT) && 151 151 (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) { … … 153 153 frac1 >>= 1; 154 154 } 155 155 156 156 if (exp >= FLOAT32_MAX_EXPONENT) { 157 157 /* TODO: fix overflow */ … … 161 161 return result; 162 162 } 163 163 164 164 exp -= FLOAT32_FRACTION_SIZE; 165 165 166 166 if (exp <= FLOAT32_FRACTION_SIZE) { 167 167 /* denormalized number */ 168 168 frac1 >>= 1; /* denormalize */ 169 169 170 170 while ((frac1 > 0) && (exp < 0)) { 171 171 frac1 >>= 1; 172 172 ++exp; 173 173 } 174 174 175 175 if (frac1 == 0) { 176 176 /* FIXME : underflow */ … … 180 180 } 181 181 } 182 182 183 183 result.parts.exp = exp; 184 184 result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1); 185 185 186 186 return result; 187 187 } … … 200 200 uint64_t frac1, frac2; 201 201 int32_t exp; 202 202 203 203 result.parts.sign = a.parts.sign ^ b.parts.sign; 204 204 205 205 if (is_float64_nan(a) || is_float64_nan(b)) { 206 206 /* TODO: fix SigNaNs */ … … 219 219 return result; 220 220 } 221 221 222 222 if (is_float64_infinity(a)) { 223 223 if (is_float64_zero(b)) { … … 230 230 return result; 231 231 } 232 232 233 233 if (is_float64_infinity(b)) { 234 234 if (is_float64_zero(a)) { … … 241 241 return result; 242 242 } 243 243 244 244 /* exp is signed so we can easy detect underflow */ 245 245 exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS; 246 246 247 247 frac1 = a.parts.fraction; 248 248 249 249 if (a.parts.exp > 0) { 250 250 frac1 |= FLOAT64_HIDDEN_BIT_MASK; … … 252 252 ++exp; 253 253 } 254 254 255 255 frac2 = b.parts.fraction; 256 256 257 257 if (b.parts.exp > 0) { 258 258 frac2 |= FLOAT64_HIDDEN_BIT_MASK; … … 260 260 ++exp; 261 261 } 262 262 263 263 frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1); 264 264 frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2); 265 265 266 266 mul64(frac1, frac2, &frac1, &frac2); 267 267 268 268 frac1 |= (frac2 != 0); 269 269 if (frac1 & (0x1ll << 62)) { … … 271 271 exp--; 272 272 } 273 273 274 274 result = finish_float64(exp, frac1, result.parts.sign); 275 275 return result; … … 289 289 uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; 290 290 int32_t exp; 291 291 292 292 result.parts.sign = a.parts.sign ^ b.parts.sign; 293 293 294 294 if (is_float128_nan(a) || is_float128_nan(b)) { 295 295 /* TODO: fix SigNaNs */ … … 311 311 return result; 312 312 } 313 313 314 314 if (is_float128_infinity(a)) { 315 315 if (is_float128_zero(b)) { … … 324 324 return result; 325 325 } 326 326 327 327 if (is_float128_infinity(b)) { 328 328 if (is_float128_zero(a)) { … … 337 337 return result; 338 338 } 339 339 340 340 /* exp is signed so we can easy detect underflow */ 341 341 exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1; 342 342 343 343 frac1_hi = a.parts.frac_hi; 344 344 frac1_lo = a.parts.frac_lo; 345 345 346 346 if (a.parts.exp > 0) { 347 347 or128(frac1_hi, frac1_lo, … … 351 351 ++exp; 352 352 } 353 353 354 354 frac2_hi = b.parts.frac_hi; 355 355 frac2_lo = b.parts.frac_lo; 356 356 357 357 if (b.parts.exp > 0) { 358 358 or128(frac2_hi, frac2_lo, … … 362 362 ++exp; 363 363 } 364 364 365 365 lshift128(frac2_hi, frac2_lo, 366 366 128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo); 367 367 368 368 tmp_hi = frac1_hi; 369 369 tmp_lo = frac1_lo; … … 372 372 add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo); 373 373 frac2_hi |= (frac2_lo != 0x0ll); 374 374 375 375 if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) { 376 376 frac2_hi >>= 1; … … 381 381 ++exp; 382 382 } 383 383 384 384 result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi); 385 385 return result; … … 392 392 float32_u ua; 393 393 ua.val = a; 394 394 395 395 float32_u ub; 396 396 ub.val = b; 397 397 398 398 float32_u res; 399 399 res.data = mul_float32(ua.data, ub.data); 400 400 401 401 return res.val; 402 402 } … … 406 406 float32_u ua; 407 407 ua.val = a; 408 408 409 409 float32_u ub; 410 410 ub.val = b; 411 411 412 412 float32_u res; 413 413 res.data = mul_float32(ua.data, ub.data); 414 414 415 415 return res.val; 416 416 } … … 424 424 float64_u ua; 425 425 ua.val = a; 426 426 427 427 float64_u ub; 428 428 ub.val = b; 429 429 430 430 float64_u res; 431 431 res.data = mul_float64(ua.data, ub.data); 432 432 433 433 return res.val; 434 434 } … … 438 438 float64_u ua; 439 439 ua.val = a; 440 440 441 441 float64_u ub; 442 442 ub.val = b; 443 443 444 444 float64_u res; 445 445 res.data = mul_float64(ua.data, ub.data); 446 446 447 447 return res.val; 448 448 } … … 456 456 float128_u ua; 457 457 ua.val = a; 458 458 459 459 float128_u ub; 460 460 ub.val = b; 461 461 462 462 float128_u res; 463 463 res.data = mul_float128(ua.data, ub.data); 464 464 465 465 return res.val; 466 466 } -
uspace/lib/softfloat/neg.c
r3061bc1 ra35b458 43 43 float32_u ua; 44 44 ua.val = a; 45 45 46 46 ua.data.parts.sign = !ua.data.parts.sign; 47 47 48 48 return ua.val; 49 49 } … … 57 57 float64_u ua; 58 58 ua.val = a; 59 59 60 60 ua.data.parts.sign = !ua.data.parts.sign; 61 61 62 62 return ua.val; 63 63 } … … 71 71 float128_u ua; 72 72 ua.val = a; 73 73 74 74 ua.data.parts.sign = !ua.data.parts.sign; 75 75 76 76 return ua.val; 77 77 } -
uspace/lib/softfloat/sub.c
r3061bc1 ra35b458 52 52 uint32_t exp1, exp2, frac1, frac2; 53 53 float32 result; 54 54 55 55 result.bin = 0; 56 56 57 57 expdiff = a.parts.exp - b.parts.exp; 58 58 if ((expdiff < 0 ) || ((expdiff == 0) && … … 62 62 // TODO: fix SigNaN 63 63 } 64 64 65 65 return b; 66 66 } 67 67 68 68 if (b.parts.exp == FLOAT32_MAX_EXPONENT) { 69 69 /* num -(+-inf) = -+inf */ … … 71 71 return b; 72 72 } 73 73 74 74 result.parts.sign = !a.parts.sign; 75 75 76 76 frac1 = b.parts.fraction; 77 77 exp1 = b.parts.exp; … … 84 84 // TODO: fix SigNaN 85 85 } 86 86 87 87 return a; 88 88 } 89 89 90 90 if (a.parts.exp == FLOAT32_MAX_EXPONENT) { 91 91 if (b.parts.exp == FLOAT32_MAX_EXPONENT) { … … 95 95 return result; 96 96 } 97 97 98 98 return a; 99 99 } 100 100 101 101 result.parts.sign = a.parts.sign; 102 102 103 103 frac1 = a.parts.fraction; 104 104 exp1 = a.parts.exp; … … 106 106 exp2 = b.parts.exp; 107 107 } 108 108 109 109 if (exp1 == 0) { 110 110 /* both are denormalized */ … … 114 114 return result; 115 115 } 116 116 117 117 result.parts.exp = 0; 118 118 return result; 119 119 } 120 120 121 121 /* add hidden bit */ 122 122 frac1 |= FLOAT32_HIDDEN_BIT_MASK; 123 123 124 124 if (exp2 == 0) { 125 125 /* denormalized */ … … 129 129 frac2 |= FLOAT32_HIDDEN_BIT_MASK; 130 130 } 131 131 132 132 /* create some space for rounding */ 133 133 frac1 <<= 6; 134 134 frac2 <<= 6; 135 135 136 136 if (expdiff > FLOAT32_FRACTION_SIZE + 1) 137 137 goto done; 138 138 139 139 frac1 = frac1 - (frac2 >> expdiff); 140 140 141 141 done: 142 142 /* TODO: find first nonzero digit and shift result and detect possibly underflow */ … … 146 146 /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ 147 147 } 148 148 149 149 /* rounding - if first bit after fraction is set then round up */ 150 150 frac1 += 0x20; 151 151 152 152 if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { 153 153 ++exp1; 154 154 frac1 >>= 1; 155 155 } 156 156 157 157 /* Clear hidden bit and shift */ 158 158 result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 159 159 result.parts.exp = exp1; 160 160 161 161 return result; 162 162 } … … 176 176 uint64_t frac1, frac2; 177 177 float64 result; 178 178 179 179 result.bin = 0; 180 180 181 181 expdiff = a.parts.exp - b.parts.exp; 182 182 if ((expdiff < 0 ) || … … 186 186 // TODO: fix SigNaN 187 187 } 188 188 189 189 return b; 190 190 } 191 191 192 192 if (b.parts.exp == FLOAT64_MAX_EXPONENT) { 193 193 /* num -(+-inf) = -+inf */ … … 195 195 return b; 196 196 } 197 197 198 198 result.parts.sign = !a.parts.sign; 199 199 200 200 frac1 = b.parts.fraction; 201 201 exp1 = b.parts.exp; … … 208 208 // TODO: fix SigNaN 209 209 } 210 210 211 211 return a; 212 212 } 213 213 214 214 if (a.parts.exp == FLOAT64_MAX_EXPONENT) { 215 215 if (b.parts.exp == FLOAT64_MAX_EXPONENT) { … … 219 219 return result; 220 220 } 221 221 222 222 return a; 223 223 } 224 224 225 225 result.parts.sign = a.parts.sign; 226 226 227 227 frac1 = a.parts.fraction; 228 228 exp1 = a.parts.exp; … … 230 230 exp2 = b.parts.exp; 231 231 } 232 232 233 233 if (exp1 == 0) { 234 234 /* both are denormalized */ … … 238 238 return result; 239 239 } 240 240 241 241 result.parts.exp = 0; 242 242 return result; 243 243 } 244 244 245 245 /* add hidden bit */ 246 246 frac1 |= FLOAT64_HIDDEN_BIT_MASK; 247 247 248 248 if (exp2 == 0) { 249 249 /* denormalized */ … … 253 253 frac2 |= FLOAT64_HIDDEN_BIT_MASK; 254 254 } 255 255 256 256 /* create some space for rounding */ 257 257 frac1 <<= 6; 258 258 frac2 <<= 6; 259 259 260 260 if (expdiff > FLOAT64_FRACTION_SIZE + 1) 261 261 goto done; 262 262 263 263 frac1 = frac1 - (frac2 >> expdiff); 264 264 265 265 done: 266 266 /* TODO: find first nonzero digit and shift result and detect possibly underflow */ … … 270 270 /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ 271 271 } 272 272 273 273 /* rounding - if first bit after fraction is set then round up */ 274 274 frac1 += 0x20; 275 275 276 276 if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { 277 277 ++exp1; 278 278 frac1 >>= 1; 279 279 } 280 280 281 281 /* Clear hidden bit and shift */ 282 282 result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); 283 283 result.parts.exp = exp1; 284 284 285 285 return result; 286 286 } … … 300 300 uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; 301 301 float128 result; 302 302 303 303 result.bin.hi = 0; 304 304 result.bin.lo = 0; 305 305 306 306 expdiff = a.parts.exp - b.parts.exp; 307 307 if ((expdiff < 0 ) || ((expdiff == 0) && … … 311 311 // TODO: fix SigNaN 312 312 } 313 313 314 314 return b; 315 315 } 316 316 317 317 if (b.parts.exp == FLOAT128_MAX_EXPONENT) { 318 318 /* num -(+-inf) = -+inf */ … … 320 320 return b; 321 321 } 322 322 323 323 result.parts.sign = !a.parts.sign; 324 324 325 325 frac1_hi = b.parts.frac_hi; 326 326 frac1_lo = b.parts.frac_lo; … … 335 335 // TODO: fix SigNaN 336 336 } 337 337 338 338 return a; 339 339 } 340 340 341 341 if (a.parts.exp == FLOAT128_MAX_EXPONENT) { 342 342 if (b.parts.exp == FLOAT128_MAX_EXPONENT) { … … 349 349 return a; 350 350 } 351 351 352 352 result.parts.sign = a.parts.sign; 353 353 354 354 frac1_hi = a.parts.frac_hi; 355 355 frac1_lo = a.parts.frac_lo; … … 359 359 exp2 = b.parts.exp; 360 360 } 361 361 362 362 if (exp1 == 0) { 363 363 /* both are denormalized */ … … 369 369 return result; 370 370 } 371 371 372 372 result.parts.exp = 0; 373 373 return result; 374 374 } 375 375 376 376 /* add hidden bit */ 377 377 or128(frac1_hi, frac1_lo, 378 378 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 379 379 &frac1_hi, &frac1_lo); 380 380 381 381 if (exp2 == 0) { 382 382 /* denormalized */ … … 388 388 &frac2_hi, &frac2_lo); 389 389 } 390 390 391 391 /* create some space for rounding */ 392 392 lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); 393 393 lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo); 394 394 395 395 if (expdiff > FLOAT128_FRACTION_SIZE + 1) 396 396 goto done; 397 397 398 398 rshift128(frac2_hi, frac2_lo, expdiff, &tmp_hi, &tmp_lo); 399 399 sub128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo); 400 400 401 401 done: 402 402 /* TODO: find first nonzero digit and shift result and detect possibly underflow */ … … 408 408 lshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); 409 409 /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ 410 410 411 411 lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6, 412 412 &tmp_hi, &tmp_lo); 413 413 and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); 414 414 } 415 415 416 416 /* rounding - if first bit after fraction is set then round up */ 417 417 add128(frac1_hi, frac1_lo, 0x0ll, 0x20ll, &frac1_hi, &frac1_lo); 418 418 419 419 lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7, 420 420 &tmp_hi, &tmp_lo); … … 424 424 rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); 425 425 } 426 426 427 427 /* Clear hidden bit and shift */ 428 428 rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); … … 432 432 result.parts.frac_hi = tmp_hi; 433 433 result.parts.frac_lo = tmp_lo; 434 434 435 435 result.parts.exp = exp1; 436 436 437 437 return result; 438 438 } … … 444 444 float32_u ua; 445 445 ua.val = a; 446 446 447 447 float32_u ub; 448 448 ub.val = b; 449 449 450 450 float32_u res; 451 451 452 452 if (ua.data.parts.sign != ub.data.parts.sign) { 453 453 ub.data.parts.sign = !ub.data.parts.sign; … … 455 455 } else 456 456 res.data = sub_float32(ua.data, ub.data); 457 457 458 458 return res.val; 459 459 } … … 463 463 float32_u ua; 464 464 ua.val = a; 465 465 466 466 float32_u ub; 467 467 ub.val = b; 468 468 469 469 float32_u res; 470 470 471 471 if (ua.data.parts.sign != ub.data.parts.sign) { 472 472 ub.data.parts.sign = !ub.data.parts.sign; … … 474 474 } else 475 475 res.data = sub_float32(ua.data, ub.data); 476 476 477 477 return res.val; 478 478 } … … 486 486 float64_u ua; 487 487 ua.val = a; 488 488 489 489 float64_u ub; 490 490 ub.val = b; 491 491 492 492 float64_u res; 493 493 494 494 if (ua.data.parts.sign != ub.data.parts.sign) { 495 495 ub.data.parts.sign = !ub.data.parts.sign; … … 497 497 } else 498 498 res.data = sub_float64(ua.data, ub.data); 499 499 500 500 return res.val; 501 501 } … … 505 505 float64_u ua; 506 506 ua.val = a; 507 507 508 508 float64_u ub; 509 509 ub.val = b; 510 510 511 511 float64_u res; 512 512 513 513 if (ua.data.parts.sign != ub.data.parts.sign) { 514 514 ub.data.parts.sign = !ub.data.parts.sign; … … 516 516 } else 517 517 res.data = sub_float64(ua.data, ub.data); 518 518 519 519 return res.val; 520 520 } … … 528 528 float128_u ua; 529 529 ua.val = a; 530 530 531 531 float128_u ub; 532 532 ub.val = b; 533 533 534 534 float128_u res; 535 535 536 536 if (ua.data.parts.sign != ub.data.parts.sign) { 537 537 ub.data.parts.sign = !ub.data.parts.sign; … … 539 539 } else 540 540 res.data = sub_float128(ua.data, ub.data); 541 541 542 542 return res.val; 543 543 }
Note:
See TracChangeset
for help on using the changeset viewer.