Changes in uspace/lib/softfloat/conversion.c [1b20da0:a35b458] in mainline
- File:
-
- 1 edited
-
uspace/lib/softfloat/conversion.c (modified) (113 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/softfloat/conversion.c
r1b20da0 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 }
Note:
See TracChangeset
for help on using the changeset viewer.
